Repository: sissbruecker/linkding
Branch: master
Commit: 573b6f5411ea
Files: 405
Total size: 1.7 MB

Directory structure:
gitextract_7gdsh6yf/

├── .coveragerc
├── .devcontainer/
│   └── devcontainer.json
├── .dockerignore
├── .gitattributes
├── .github/
│   └── workflows/
│       ├── build-test.yaml
│       ├── build.yaml
│       └── main.yaml
├── .gitignore
├── CHANGELOG.md
├── LICENSE.txt
├── Makefile
├── README.md
├── SECURITY.md
├── assets/
│   ├── header.afdesign
│   ├── logo-inset.afdesign
│   ├── logo.afdesign
│   └── social-preview.afdesign
├── bookmarks/
│   ├── __init__.py
│   ├── admin.py
│   ├── api/
│   │   ├── __init__.py
│   │   ├── auth.py
│   │   ├── routes.py
│   │   └── serializers.py
│   ├── apps.py
│   ├── context_processors.py
│   ├── feeds.py
│   ├── forms.py
│   ├── frontend/
│   │   ├── api.js
│   │   ├── components/
│   │   │   ├── bookmark-page.js
│   │   │   ├── clear-button.js
│   │   │   ├── confirm-dropdown.js
│   │   │   ├── details-modal.js
│   │   │   ├── dev-tool.js
│   │   │   ├── dropdown.js
│   │   │   ├── filter-drawer.js
│   │   │   ├── form.js
│   │   │   ├── modal.js
│   │   │   ├── search-autocomplete.js
│   │   │   ├── tag-autocomplete.js
│   │   │   └── upload-button.js
│   │   ├── index.js
│   │   ├── shortcuts.js
│   │   └── utils/
│   │       ├── element.js
│   │       ├── focus.js
│   │       ├── input.js
│   │       ├── position-controller.js
│   │       ├── search-history.js
│   │       └── tag-cache.js
│   ├── management/
│   │   └── commands/
│   │       ├── backup.py
│   │       ├── create_initial_superuser.py
│   │       ├── enable_wal.py
│   │       ├── ensure_superuser.py
│   │       ├── full_backup.py
│   │       ├── generate_secret_key.py
│   │       ├── import_netscape.py
│   │       └── migrate_tasks.py
│   ├── middlewares.py
│   ├── migrations/
│   │   ├── 0001_initial.py
│   │   ├── 0002_auto_20190629_2303.py
│   │   ├── 0003_auto_20200913_0656.py
│   │   ├── 0004_auto_20200926_1028.py
│   │   ├── 0005_auto_20210103_1212.py
│   │   ├── 0006_bookmark_is_archived.py
│   │   ├── 0007_userprofile.py
│   │   ├── 0008_userprofile_bookmark_date_display.py
│   │   ├── 0009_bookmark_web_archive_snapshot_url.py
│   │   ├── 0010_userprofile_bookmark_link_target.py
│   │   ├── 0011_userprofile_web_archive_integration.py
│   │   ├── 0012_toast.py
│   │   ├── 0013_web_archive_optin_toast.py
│   │   ├── 0014_alter_bookmark_unread.py
│   │   ├── 0015_feedtoken.py
│   │   ├── 0016_bookmark_shared.py
│   │   ├── 0017_userprofile_enable_sharing.py
│   │   ├── 0018_bookmark_favicon_file.py
│   │   ├── 0019_userprofile_enable_favicons.py
│   │   ├── 0020_userprofile_tag_search.py
│   │   ├── 0021_userprofile_display_url.py
│   │   ├── 0022_bookmark_notes.py
│   │   ├── 0023_userprofile_permanent_notes.py
│   │   ├── 0024_userprofile_enable_public_sharing.py
│   │   ├── 0025_userprofile_search_preferences.py
│   │   ├── 0026_userprofile_custom_css.py
│   │   ├── 0027_userprofile_bookmark_description_display_and_more.py
│   │   ├── 0028_userprofile_display_archive_bookmark_action_and_more.py
│   │   ├── 0029_bookmark_list_actions_toast.py
│   │   ├── 0030_bookmarkasset.py
│   │   ├── 0031_userprofile_enable_automatic_html_snapshots.py
│   │   ├── 0032_html_snapshots_hint_toast.py
│   │   ├── 0033_userprofile_default_mark_unread.py
│   │   ├── 0034_bookmark_preview_image_file_and_more.py
│   │   ├── 0035_userprofile_tag_grouping.py
│   │   ├── 0036_userprofile_auto_tagging_rules.py
│   │   ├── 0037_globalsettings.py
│   │   ├── 0038_globalsettings_guest_profile_user.py
│   │   ├── 0039_globalsettings_enable_link_prefetch.py
│   │   ├── 0040_userprofile_items_per_page_and_more.py
│   │   ├── 0041_merge_metadata.py
│   │   ├── 0042_userprofile_custom_css_hash.py
│   │   ├── 0043_userprofile_collapse_side_panel.py
│   │   ├── 0044_bookmark_latest_snapshot.py
│   │   ├── 0045_userprofile_hide_bundles_bookmarkbundle.py
│   │   ├── 0046_add_url_normalized_field.py
│   │   ├── 0047_populate_url_normalized_field.py
│   │   ├── 0048_userprofile_default_mark_shared.py
│   │   ├── 0049_userprofile_legacy_search.py
│   │   ├── 0050_new_search_toast.py
│   │   ├── 0051_fix_normalized_url.py
│   │   ├── 0052_apitoken.py
│   │   ├── 0053_migrate_api_tokens.py
│   │   ├── 0054_bookmarkbundle_filter_shared_and_more.py
│   │   └── __init__.py
│   ├── models.py
│   ├── queries.py
│   ├── services/
│   │   ├── __init__.py
│   │   ├── assets.py
│   │   ├── auto_tagging.py
│   │   ├── bookmarks.py
│   │   ├── bundles.py
│   │   ├── exporter.py
│   │   ├── favicon_loader.py
│   │   ├── importer.py
│   │   ├── monolith.py
│   │   ├── parser.py
│   │   ├── preview_image_loader.py
│   │   ├── search_query_parser.py
│   │   ├── singlefile.py
│   │   ├── tags.py
│   │   ├── tasks.py
│   │   ├── wayback.py
│   │   └── website_loader.py
│   ├── settings/
│   │   ├── __init__.py
│   │   ├── base.py
│   │   ├── custom.py
│   │   ├── dev.py
│   │   └── prod.py
│   ├── signals.py
│   ├── static/
│   │   ├── live-reload.js
│   │   ├── robots.txt
│   │   └── vendor/
│   │       └── Readability.js
│   ├── styles/
│   │   ├── auth.css
│   │   ├── bookmark-details.css
│   │   ├── bookmark-form.css
│   │   ├── bookmark-page.css
│   │   ├── bundles.css
│   │   ├── components.css
│   │   ├── crud.css
│   │   ├── layout.css
│   │   ├── markdown.css
│   │   ├── reader-mode.css
│   │   ├── responsive.css
│   │   ├── settings.css
│   │   ├── tags.css
│   │   ├── theme/
│   │   │   ├── LICENSE
│   │   │   ├── _normalize.css
│   │   │   ├── animations.css
│   │   │   ├── asian.css
│   │   │   ├── autocomplete.css
│   │   │   ├── badges.css
│   │   │   ├── base.css
│   │   │   ├── buttons.css
│   │   │   ├── code.css
│   │   │   ├── dropdowns.css
│   │   │   ├── empty.css
│   │   │   ├── forms.css
│   │   │   ├── menus.css
│   │   │   ├── modals.css
│   │   │   ├── pagination.css
│   │   │   ├── tables.css
│   │   │   ├── tabs.css
│   │   │   ├── toasts.css
│   │   │   ├── typography.css
│   │   │   ├── utilities.css
│   │   │   └── variables.css
│   │   ├── theme-dark.css
│   │   └── theme-light.css
│   ├── tasks.py
│   ├── templates/
│   │   ├── admin/
│   │   │   └── background_tasks.html
│   │   ├── bookmarks/
│   │   │   ├── bookmark_list.html
│   │   │   ├── bookmark_page.html
│   │   │   ├── bulk_edit_bar.html
│   │   │   ├── bundle_section.html
│   │   │   ├── close.html
│   │   │   ├── details/
│   │   │   │   ├── asset_icon.html
│   │   │   │   ├── assets.html
│   │   │   │   ├── form.html
│   │   │   │   └── modal.html
│   │   │   ├── edit.html
│   │   │   ├── empty_bookmarks.html
│   │   │   ├── form.html
│   │   │   ├── new.html
│   │   │   ├── read.html
│   │   │   ├── search.html
│   │   │   ├── tag_cloud.html
│   │   │   ├── tag_section.html
│   │   │   └── user_section.html
│   │   ├── bundles/
│   │   │   ├── edit.html
│   │   │   ├── form.html
│   │   │   ├── index.html
│   │   │   ├── new.html
│   │   │   └── preview.html
│   │   ├── opensearch.xml
│   │   ├── registration/
│   │   │   ├── login.html
│   │   │   ├── password_change_done.html
│   │   │   └── password_change_form.html
│   │   ├── settings/
│   │   │   ├── bookmarklet.js
│   │   │   ├── bookmarklet_clientside.js
│   │   │   ├── create_api_token_modal.html
│   │   │   ├── general.html
│   │   │   └── integrations.html
│   │   ├── shared/
│   │   │   ├── dev_tool.html
│   │   │   ├── error_list.html
│   │   │   ├── head.html
│   │   │   ├── layout.html
│   │   │   ├── messages.html
│   │   │   ├── modal_header.html
│   │   │   ├── nav_menu.html
│   │   │   ├── pagination.html
│   │   │   └── top_frame.html
│   │   └── tags/
│   │       ├── edit.html
│   │       ├── form.html
│   │       ├── index.html
│   │       ├── merge.html
│   │       └── new.html
│   ├── templatetags/
│   │   ├── __init__.py
│   │   ├── bookmarks.py
│   │   ├── pagination.py
│   │   └── shared.py
│   ├── tests/
│   │   ├── __init__.py
│   │   ├── helpers.py
│   │   ├── resources/
│   │   │   ├── simple_valid_import_file.html
│   │   │   └── simple_valid_import_file_with_one_invalid_bookmark.html
│   │   ├── test_app_options.py
│   │   ├── test_assets_service.py
│   │   ├── test_auth_api.py
│   │   ├── test_auth_proxy_support.py
│   │   ├── test_auto_tagging.py
│   │   ├── test_bookmark_action_view.py
│   │   ├── test_bookmark_archived_view.py
│   │   ├── test_bookmark_archived_view_performance.py
│   │   ├── test_bookmark_asset_view.py
│   │   ├── test_bookmark_assets.py
│   │   ├── test_bookmark_assets_api.py
│   │   ├── test_bookmark_details_modal.py
│   │   ├── test_bookmark_edit_view.py
│   │   ├── test_bookmark_index_view.py
│   │   ├── test_bookmark_index_view_performance.py
│   │   ├── test_bookmark_new_view.py
│   │   ├── test_bookmark_previews.py
│   │   ├── test_bookmark_search_form.py
│   │   ├── test_bookmark_search_model.py
│   │   ├── test_bookmark_search_tag.py
│   │   ├── test_bookmark_shared_view.py
│   │   ├── test_bookmark_shared_view_performance.py
│   │   ├── test_bookmark_validation.py
│   │   ├── test_bookmarks_api.py
│   │   ├── test_bookmarks_api_performance.py
│   │   ├── test_bookmarks_api_permissions.py
│   │   ├── test_bookmarks_list_template.py
│   │   ├── test_bookmarks_model.py
│   │   ├── test_bookmarks_service.py
│   │   ├── test_bookmarks_tasks.py
│   │   ├── test_bundles_api.py
│   │   ├── test_bundles_edit_view.py
│   │   ├── test_bundles_index_view.py
│   │   ├── test_bundles_new_view.py
│   │   ├── test_bundles_preview_view.py
│   │   ├── test_context_path.py
│   │   ├── test_create_initial_superuser_command.py
│   │   ├── test_custom_css_view.py
│   │   ├── test_exporter.py
│   │   ├── test_exporter_performance.py
│   │   ├── test_favicon_loader.py
│   │   ├── test_feeds.py
│   │   ├── test_feeds_performance.py
│   │   ├── test_health_view.py
│   │   ├── test_importer.py
│   │   ├── test_layout.py
│   │   ├── test_linkding_middleware.py
│   │   ├── test_login_view.py
│   │   ├── test_metadata_view.py
│   │   ├── test_monolith_service.py
│   │   ├── test_oidc_support.py
│   │   ├── test_opensearch_view.py
│   │   ├── test_pagination_tag.py
│   │   ├── test_parser.py
│   │   ├── test_password_change_view.py
│   │   ├── test_preview_image_loader.py
│   │   ├── test_queries.py
│   │   ├── test_root_view.py
│   │   ├── test_search_query_parser.py
│   │   ├── test_settings_export_view.py
│   │   ├── test_settings_general_view.py
│   │   ├── test_settings_import_view.py
│   │   ├── test_settings_integrations_view.py
│   │   ├── test_singlefile_service.py
│   │   ├── test_tag_cloud_template.py
│   │   ├── test_tags_edit_view.py
│   │   ├── test_tags_index_view.py
│   │   ├── test_tags_merge_view.py
│   │   ├── test_tags_model.py
│   │   ├── test_tags_new_view.py
│   │   ├── test_tags_service.py
│   │   ├── test_toasts_view.py
│   │   ├── test_user_profile_model.py
│   │   ├── test_user_select_tag.py
│   │   ├── test_utils.py
│   │   └── test_website_loader.py
│   ├── tests_e2e/
│   │   ├── __init__.py
│   │   ├── e2e_test_a11y_navigation_focus.py
│   │   ├── e2e_test_bookmark_details_modal.py
│   │   ├── e2e_test_bookmark_item.py
│   │   ├── e2e_test_bookmark_page_bulk_edit.py
│   │   ├── e2e_test_bookmark_page_partial_updates.py
│   │   ├── e2e_test_bundle_preview.py
│   │   ├── e2e_test_collapse_side_panel.py
│   │   ├── e2e_test_dropdown.py
│   │   ├── e2e_test_edit_bookmark_form.py
│   │   ├── e2e_test_filter_drawer.py
│   │   ├── e2e_test_global_shortcuts.py
│   │   ├── e2e_test_new_bookmark_form.py
│   │   ├── e2e_test_settings_general.py
│   │   ├── e2e_test_settings_integrations.py
│   │   ├── e2e_test_tag_management.py
│   │   └── helpers.py
│   ├── type_defs.py
│   ├── urls.py
│   ├── utils.py
│   ├── validators.py
│   ├── views/
│   │   ├── __init__.py
│   │   ├── access.py
│   │   ├── assets.py
│   │   ├── auth.py
│   │   ├── bookmarks.py
│   │   ├── bundles.py
│   │   ├── contexts.py
│   │   ├── custom_css.py
│   │   ├── health.py
│   │   ├── manifest.py
│   │   ├── opensearch.py
│   │   ├── reload.py
│   │   ├── root.py
│   │   ├── settings.py
│   │   ├── tags.py
│   │   ├── toasts.py
│   │   └── turbo.py
│   ├── widgets.py
│   └── wsgi.py
├── bootstrap.sh
├── docker/
│   ├── alpine.Dockerfile
│   └── default.Dockerfile
├── docker-compose.yml
├── docs/
│   ├── .gitignore
│   ├── README.md
│   ├── astro.config.mjs
│   ├── package.json
│   ├── src/
│   │   ├── assets/
│   │   │   ├── Add To Linkding.shortcut
│   │   │   └── linkding_shortcut.json
│   │   ├── components/
│   │   │   ├── Card.astro
│   │   │   └── icons.ts
│   │   ├── content/
│   │   │   ├── config.ts
│   │   │   └── docs/
│   │   │       ├── acknowledgements.md
│   │   │       ├── admin.md
│   │   │       ├── api.md
│   │   │       ├── archiving.md
│   │   │       ├── auto-tagging.md
│   │   │       ├── backups.md
│   │   │       ├── browser-extension.md
│   │   │       ├── community.md
│   │   │       ├── how-to.md
│   │   │       ├── index.mdx
│   │   │       ├── installation.md
│   │   │       ├── managed-hosting.md
│   │   │       ├── options.md
│   │   │       ├── search.md
│   │   │       ├── shortcuts.md
│   │   │       └── troubleshooting.md
│   │   ├── env.d.ts
│   │   └── styles/
│   │       └── custom.css
│   └── tsconfig.json
├── install-linkding.sh
├── manage.py
├── package.json
├── postcss.config.js
├── pyproject.toml
├── pytest.ini
├── rollup.config.mjs
├── scripts/
│   ├── build-docker.sh
│   ├── coverage.sh
│   ├── generate-changelog.py
│   ├── release.sh
│   ├── run-docker.sh
│   ├── run-postgres.sh
│   ├── setup-ublock.sh
│   ├── test-environments/
│   │   ├── authelia-oidc/
│   │   │   ├── authelia/
│   │   │   │   ├── configuration.yml
│   │   │   │   └── users_database.yml
│   │   │   ├── compose.yml
│   │   │   ├── setup.sh
│   │   │   └── traefik/
│   │   │       └── certificates.yml
│   │   └── postgres/
│   │       └── compose.yml
│   └── test-postgres.sh
├── supervisord-all.conf
├── supervisord-tasks.conf
├── uwsgi.ini
└── version.txt

================================================
FILE CONTENTS
================================================

================================================
FILE: .coveragerc
================================================
[run]
source = bookmarks
omit = bookmarks/tests/*


================================================
FILE: .devcontainer/devcontainer.json
================================================
// 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:3.13",
	"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": "pip install uv && uv sync --group dev && npm install && mkdir -p data && uv run manage.py migrate",

	// Configure tool-specific properties.
	"customizations": {
		"vscode": {
			"extensions": [
				"ms-python.python"
			]
		}
	},

	"remoteUser": "vscode"
}


================================================
FILE: .dockerignore
================================================
# Ignore everything
*

# Include files required for build or at runtime
!/bookmarks

!/bootstrap.sh
!/LICENSE.txt
!/manage.py
!/package.json
!/package-lock.json
!/postcss.config.js
!/pyproject.toml
!/rollup.config.mjs
!/supervisord-tasks.conf
!/supervisord-all.conf
!/uv.lock
!/uwsgi.ini
!/version.txt

 # Remove dev settings
/bookmarks/settings/dev.py


================================================
FILE: .gitattributes
================================================
* text=auto
*.sh text eol=lf

================================================
FILE: .github/workflows/build-test.yaml
================================================
name: build-test

on: workflow_dispatch

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4

      - name: Login to Docker Hub
        uses: docker/login-action@v3
        with:
          username: ${{ vars.DOCKERHUB_USERNAME }}
          password: ${{ secrets.DOCKERHUB_TOKEN }}

      - name: Login to GitHub Container Registry
        uses: docker/login-action@v3
        with:
          registry: ghcr.io
          username: ${{ github.actor }}
          password: ${{ github.token }}

      - name: Set up QEMU
        uses: docker/setup-qemu-action@v3

      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v3

      - name: Build latest
        uses: docker/build-push-action@v6
        with:
          context: .
          file: ./docker/default.Dockerfile
          platforms: linux/amd64,linux/arm64,linux/arm/v7
          tags: |
            ghcr.io/sissbruecker/linkding:test
          target: linkding
          push: true
          cache-from: type=registry,ref=ghcr.io/sissbruecker/linkding:buildcache
          cache-to: type=registry,ref=ghcr.io/sissbruecker/linkding:buildcache,mode=max

      - name: Build latest-alpine
        uses: docker/build-push-action@v6
        with:
          context: .
          file: ./docker/alpine.Dockerfile
          platforms: linux/amd64,linux/arm64,linux/arm/v7
          tags: |
            ghcr.io/sissbruecker/linkding:test-alpine
          target: linkding
          push: true
          cache-from: type=registry,ref=ghcr.io/sissbruecker/linkding:buildcache-alpine
          cache-to: type=registry,ref=ghcr.io/sissbruecker/linkding:buildcache-alpine,mode=max

      - name: Build latest-plus
        uses: docker/build-push-action@v6
        with:
          context: .
          file: ./docker/default.Dockerfile
          platforms: linux/amd64,linux/arm64,linux/arm/v7
          tags: |
            ghcr.io/sissbruecker/linkding:test-plus
          target: linkding-plus
          push: true
          cache-from: type=registry,ref=ghcr.io/sissbruecker/linkding:buildcache
          cache-to: type=registry,ref=ghcr.io/sissbruecker/linkding:buildcache,mode=max

      - name: Build latest-plus-alpine
        uses: docker/build-push-action@v6
        with:
          context: .
          file: ./docker/alpine.Dockerfile
          platforms: linux/amd64,linux/arm64,linux/arm/v7
          tags: |
            ghcr.io/sissbruecker/linkding:test-plus-alpine
          target: linkding-plus
          push: true
          cache-from: type=registry,ref=ghcr.io/sissbruecker/linkding:buildcache-alpine
          cache-to: type=registry,ref=ghcr.io/sissbruecker/linkding:buildcache-alpine,mode=max


================================================
FILE: .github/workflows/build.yaml
================================================
name: build

on: workflow_dispatch

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4

      - name: Read version from file
        id: get_version
        run: echo "VERSION=$(cat version.txt)" >> $GITHUB_ENV

      - name: Login to Docker Hub
        uses: docker/login-action@v3
        with:
          username: ${{ vars.DOCKERHUB_USERNAME }}
          password: ${{ secrets.DOCKERHUB_TOKEN }}

      - name: Login to GitHub Container Registry
        uses: docker/login-action@v3
        with:
          registry: ghcr.io
          username: ${{ github.actor }}
          password: ${{ github.token }}

      - name: Set up QEMU
        uses: docker/setup-qemu-action@v3

      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v3

      - name: Build latest
        uses: docker/build-push-action@v6
        with:
          context: .
          file: ./docker/default.Dockerfile
          platforms: linux/amd64,linux/arm64,linux/arm/v7
          tags: |
            sissbruecker/linkding:latest
            sissbruecker/linkding:${{ env.VERSION }}
            ghcr.io/sissbruecker/linkding:latest
            ghcr.io/sissbruecker/linkding:${{ env.VERSION }}
          target: linkding
          push: true
          cache-from: type=registry,ref=ghcr.io/sissbruecker/linkding:buildcache
          cache-to: type=registry,ref=ghcr.io/sissbruecker/linkding:buildcache,mode=max

      - name: Build latest-alpine
        uses: docker/build-push-action@v6
        with:
          context: .
          file: ./docker/alpine.Dockerfile
          platforms: linux/amd64,linux/arm64,linux/arm/v7
          tags: |
            sissbruecker/linkding:latest-alpine
            sissbruecker/linkding:${{ env.VERSION }}-alpine
            ghcr.io/sissbruecker/linkding:latest-alpine
            ghcr.io/sissbruecker/linkding:${{ env.VERSION }}-alpine
          target: linkding
          push: true
          cache-from: type=registry,ref=ghcr.io/sissbruecker/linkding:buildcache-alpine
          cache-to: type=registry,ref=ghcr.io/sissbruecker/linkding:buildcache-alpine,mode=max

      - name: Build latest-plus
        uses: docker/build-push-action@v6
        with:
          context: .
          file: ./docker/default.Dockerfile
          platforms: linux/amd64,linux/arm64,linux/arm/v7
          tags: |
            sissbruecker/linkding:latest-plus
            sissbruecker/linkding:${{ env.VERSION }}-plus
            ghcr.io/sissbruecker/linkding:latest-plus
            ghcr.io/sissbruecker/linkding:${{ env.VERSION }}-plus
          target: linkding-plus
          push: true
          cache-from: type=registry,ref=ghcr.io/sissbruecker/linkding:buildcache
          cache-to: type=registry,ref=ghcr.io/sissbruecker/linkding:buildcache,mode=max

      - name: Build latest-plus-alpine
        uses: docker/build-push-action@v6
        with:
          context: .
          file: ./docker/alpine.Dockerfile
          platforms: linux/amd64,linux/arm64,linux/arm/v7
          tags: |
            sissbruecker/linkding:latest-plus-alpine
            sissbruecker/linkding:${{ env.VERSION }}-plus-alpine
            ghcr.io/sissbruecker/linkding:latest-plus-alpine
            ghcr.io/sissbruecker/linkding:${{ env.VERSION }}-plus-alpine
          target: linkding-plus
          push: true
          cache-from: type=registry,ref=ghcr.io/sissbruecker/linkding:buildcache-alpine
          cache-to: type=registry,ref=ghcr.io/sissbruecker/linkding:buildcache-alpine,mode=max

================================================
FILE: .github/workflows/main.yaml
================================================
name: linkding CI

on:
  pull_request:
  push:
    branches:
      - master

jobs:
  unit_tests:
    name: Unit Tests
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: "3.13"
      - name: Install uv
        uses: astral-sh/setup-uv@v6
      - name: Set up Node
        uses: actions/setup-node@v4
        with:
          node-version: 20
          cache: 'npm'
      - name: Install Node dependencies
        run: npm ci
      - name: Setup Python environment
        run: |
          uv sync
          mkdir data
      - name: Run tests
        run: uv run pytest -n auto
  e2e_tests:
    name: E2E Tests
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: "3.13"
      - name: Install uv
        uses: astral-sh/setup-uv@v6
      - name: Set up Node
        uses: actions/setup-node@v4
        with:
          node-version: 20
          cache: 'npm'
      - name: Install Node dependencies
        run: npm ci
      - name: Setup Python environment
        run: |
          uv sync
          uv run playwright install chromium
          mkdir data
      - name: Run build
        run: |
          npm run build
          uv run manage.py collectstatic
      - name: Run tests
        run: uv run pytest bookmarks/tests_e2e -n auto -o "python_files=e2e_test_*.py"
      - name: Upload screenshots
        if: failure()
        uses: actions/upload-artifact@v4
        with:
          name: e2e-screenshots
          path: test-results/screenshots


================================================
FILE: .gitignore
================================================
# Created by .ignore support plugin (hsz.mobi)
### JetBrains template
# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and WebStorm
# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839

# File-based project format
*.iws

# IntelliJ
.idea
*.iml
out/

### Python template
# Byte-compiled / optimized / DLL files
__pycache__/
*.py[cod]
*$py.class

# C extensions
*.so

# Distribution / packaging
.Python
build/
develop-eggs/
dist/
downloads/
eggs/
.eggs/
lib/
lib64/
parts/
sdist/
var/
wheels/
*.egg-info/
.installed.cfg
*.egg
MANIFEST

# PyInstaller
#  Usually these files are written by a python script from a template
#  before PyInstaller builds the exe, so as to inject date/other infos into it.
*.manifest
*.spec

# Installer logs
pip-log.txt
pip-delete-this-directory.txt

# Unit test / coverage reports
htmlcov/
.tox/
.coverage
.coverage.*
.cache
nosetests.xml
coverage.xml
*.cover
.hypothesis/
.pytest_cache/
test-results/

# Translations
*.mo
*.pot

# Django stuff:
*.log
local_settings.py
db.sqlite3

# Flask stuff:
instance/
.webassets-cache

# Scrapy stuff:
.scrapy

# Sphinx documentation
docs/_build/

# PyBuilder
target/

# Jupyter Notebook
.ipynb_checkpoints

# pyenv
.python-version

# celery beat schedule file
celerybeat-schedule

# SageMath parsed files
*.sage.py

# Environments
.env
.venv
env/
venv/
ENV/
env.bak/
venv.bak/

# Spyder project settings
.spyderproject
.spyproject

# Rope project settings
.ropeproject

# mkdocs documentation
/site

# mypy
.mypy_cache/

### Node template
# Logs
logs
*.log
npm-debug.log*
yarn-debug.log*
yarn-error.log*

# Runtime data
pids
*.pid
*.seed
*.pid.lock

# Directory for instrumented libs generated by jscoverage/JSCover
lib-cov

# Coverage directory used by tools like istanbul
coverage

# nyc test coverage
.nyc_output

# Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
.grunt

# Bower dependency directory (https://bower.io/)
bower_components

# node-waf configuration
.lock-wscript

# Compiled binary addons (https://nodejs.org/api/addons.html)
build/Release

# Dependency directories
node_modules/
jspm_packages/

# TypeScript v1 declaration files
typings/

# Optional npm cache directory
.npm

# Optional eslint cache
.eslintcache

# Optional REPL history
.node_repl_history

# Output of 'npm pack'
*.tgz

# Yarn Integrity file
.yarn-integrity

# dotenv environment variables file
.env

# next.js build output
.next

### Custom
# Rollup compilation output
/bookmarks/static/bundle.js*
# CSS compilation output
/bookmarks/static/theme-*.css*
# Collected static files for deployment
/static
# Build output, etc.
/tmp
# Database file
/data
# ublock + chromium
/uBOLite.chromium.mv3
/chromium-profile
# direnv
/.direnv

# Test setups
/scripts/unsecure-test-setups/authelia-oidc/authelia/db.sqlite3
/scripts/unsecure-test-setups/authelia-oidc/traefik/certs


================================================
FILE: CHANGELOG.md
================================================
# Changelog

## v1.45.0 (06/01/2026)

### What's Changed
* API token management by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1248
* Add option to disable login form by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1269
* Turn scheme-less URLs into HTTPS instead of HTTP links by @Maaxxs in https://github.com/sissbruecker/linkding/pull/1225
* Disable bulk execute button when no bookmarks selected by @emanuelebeffa in https://github.com/sissbruecker/linkding/pull/1241
* Add option to run supervisor as main process by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1270
* Allow setting date_added and date_modified for new bookmarks through REST API by @jmason in https://github.com/sissbruecker/linkding/pull/1063
* Download PDF instead of creating HTML snapshot if URL points at PDF by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1271
* Allow sandboxed scripts when viewing assets by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1252
* Allow viewing video assets by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1259
* Remove absolute URIs from settings page by @packrat386 in https://github.com/sissbruecker/linkding/pull/1261
* Move tag management forms into dialogs by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1253
* Move bulk edit checkboxes into bookmark list container by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1257
* Remove registration switch by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1268
* Add linkdinger to community projects by @lmmendes in https://github.com/sissbruecker/linkding/pull/1266

### New Contributors
* @packrat386 made their first contribution in https://github.com/sissbruecker/linkding/pull/1261
* @lmmendes made their first contribution in https://github.com/sissbruecker/linkding/pull/1266
* @Maaxxs made their first contribution in https://github.com/sissbruecker/linkding/pull/1225
* @emanuelebeffa made their first contribution in https://github.com/sissbruecker/linkding/pull/1241
* @jmason made their first contribution in https://github.com/sissbruecker/linkding/pull/1063

**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.44.2...v1.45.0

---

## v1.44.2 (13/12/2025)

### What's Changed

> [!WARNING] 
> *This resolves a [security vulnerability](https://github.com/sissbruecker/linkding/security/advisories/GHSA-3pf9-5cjv-2w7q) in linkding. Everyone is encouraged to upgrade to the latest version as soon as possible.*

* Use sandbox CSP for viewing assets by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1245
* Fix devcontainer by @m3eno in https://github.com/sissbruecker/linkding/pull/1208
* Fix tag cloud highlighting first char when tags are not grouped by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1209
* Bump supervisor to 4.3.0 to fix warning by @simonhammes in https://github.com/sissbruecker/linkding/pull/1216
* Added Javascript client and library for Linkding REST API by @vbsampath in https://github.com/sissbruecker/linkding/pull/1195
* Add Komrade project to community resources by @dev-inside in https://github.com/sissbruecker/linkding/pull/1236

### New Contributors
* @m3eno made their first contribution in https://github.com/sissbruecker/linkding/pull/1208
* @vbsampath made their first contribution in https://github.com/sissbruecker/linkding/pull/1195
* @dev-inside made their first contribution in https://github.com/sissbruecker/linkding/pull/1236
* @simonhammes made their first contribution in https://github.com/sissbruecker/linkding/pull/1216

**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.44.1...v1.44.2

---

## v1.44.1 (11/10/2025)

### What's Changed
* Fix normalized URL not being generated in bookmark import by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1202
* Fix missing tags causing errors in import with Postgres by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1203
* Check for dupes by exact URL if normalized URL is missing by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1204
* Attempt to fix botched normalized URL migration from 1.43.0 by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1205


**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.44.0...v1.44.1

---

## v1.44.0 (05/10/2025)

### What's Changed
* Add new search engine that supports logical expressions (and, or, not) by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1198
* Fix pagination links to use relative URLs by @dunlor in https://github.com/sissbruecker/linkding/pull/1186
* Fix queued tasks link when context path is used by @dunlor in https://github.com/sissbruecker/linkding/pull/1187
* Fix bundle preview pagination resetting to first page by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1194

### New Contributors
* @dunlor made their first contribution in https://github.com/sissbruecker/linkding/pull/1186

**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.43.0...v1.44.0

---

## v1.43.0 (28/09/2025)

### What's Changed
* Add basic tag management by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1175
* Normalize URLs when checking for duplicates by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1169
* Add option to mark bookmarks as shared by default by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1170
* Use modal dialog for confirming actions by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1168
* Fix error when filtering bookmark assets in the admin UI by @proog in https://github.com/sissbruecker/linkding/pull/1162
* Document API bundle filter by @proog in https://github.com/sissbruecker/linkding/pull/1161
* Add alfred-linkding-bookmarks to community.md by @FireFingers21 in https://github.com/sissbruecker/linkding/pull/1160
* Switch to uv by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1172
* Replace Svelte components with Lit elements by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1174
* Bump versions by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1173
* Bump astro from 5.12.8 to 5.13.2 in /docs by @dependabot[bot] in https://github.com/sissbruecker/linkding/pull/1166
* Bump vite from 6.3.5 to 6.3.6 in /docs by @dependabot[bot] in https://github.com/sissbruecker/linkding/pull/1184

### New Contributors
* @FireFingers21 made their first contribution in https://github.com/sissbruecker/linkding/pull/1160

**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.42.0...v1.43.0

---

## v1.42.0 (16/08/2025)

### What's Changed
* Bulk create HTML snapshots by @Tql-ws1 in https://github.com/sissbruecker/linkding/pull/1132
* Create bundle from current search query by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1154
* Add alternative bookmarklet that uses browser metadata by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1159
* Add date and time to HTML export filename by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1101
* Automatically compress uploads with gzip by @hkclark in https://github.com/sissbruecker/linkding/pull/1087
* Show bookmark bundles in admin by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1110
* Allow filtering feeds by bundle by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1152
* Submit bookmark form with Ctrl/Cmd + Enter by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1158
* Improve bookmark form accessibility by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1116
* Fix custom CSS not being used in reader mode by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1102
* Use filename when downloading asset through UI by @proog in https://github.com/sissbruecker/linkding/pull/1146
* Update order when deleting bundle by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1114
* Wrap long titles in bookmark details modal by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1150
* Ignore tags with just whitespace by @pvl in https://github.com/sissbruecker/linkding/pull/1125
* Ignore tags that exceed length limit during import by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1153
* Add CloudBreak on Managed Hosting by @benjaminoakes in https://github.com/sissbruecker/linkding/pull/1079
* Add Pocket migration to to community page by @hkclark in https://github.com/sissbruecker/linkding/pull/1112
* Add linkding-media-archiver to community.md by @proog in https://github.com/sissbruecker/linkding/pull/1144
* Bump astro from 5.7.13 to 5.12.8 in /docs by @dependabot[bot] in https://github.com/sissbruecker/linkding/pull/1147

### New Contributors
* @hkclark made their first contribution in https://github.com/sissbruecker/linkding/pull/1087
* @benjaminoakes made their first contribution in https://github.com/sissbruecker/linkding/pull/1079
* @proog made their first contribution in https://github.com/sissbruecker/linkding/pull/1146
* @pvl made their first contribution in https://github.com/sissbruecker/linkding/pull/1125
* @Tql-ws1 made their first contribution in https://github.com/sissbruecker/linkding/pull/1132

**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.41.0...v1.42.0

---

## v1.41.0 (19/06/2025)

### What's Changed
* Add bundles for organizing bookmarks by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1097
* Add REST API for bookmark bundles by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1100
* Add date filters for REST API by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1080
* Fix side panel not being hidden on smaller viewports by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1089
* Fix assets not using correct icon by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1098
* Add LinkBuddy to community section by @peterto in https://github.com/sissbruecker/linkding/pull/1088
* Bump tar-fs in /docs by @dependabot in https://github.com/sissbruecker/linkding/pull/1084
* Bump django from 5.1.9 to 5.1.10 by @dependabot in https://github.com/sissbruecker/linkding/pull/1086
* Bump requests from 2.32.3 to 2.32.4 by @dependabot in https://github.com/sissbruecker/linkding/pull/1090
* Bump urllib3 from 2.2.3 to 2.5.0 by @dependabot in https://github.com/sissbruecker/linkding/pull/1096

### New Contributors
* @peterto made their first contribution in https://github.com/sissbruecker/linkding/pull/1088

**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.40.0...v1.41.0

---

## v1.40.0 (17/05/2025)

### What's Changed
* Add bulk and single bookmark metadata refresh by @Teknicallity in https://github.com/sissbruecker/linkding/pull/999
* Prefer local snapshot over web archive link in bookmark list links by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1021
* Push Docker images to GHCR in addition to Docker Hub by @caycehouse in https://github.com/sissbruecker/linkding/pull/1024
* Allow auto tagging rules to match URL fragments by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1045
* Linkify plain URLs in notes by @sonicdoe in https://github.com/sissbruecker/linkding/pull/1051
* Add opensearch declaration by @jzorn in https://github.com/sissbruecker/linkding/pull/1058
* Allow pre-filling tags in new bookmark form by @dasrecht in https://github.com/sissbruecker/linkding/pull/1060
* Handle lowercase "true" in environment variables by @jose-elias-alvarez in https://github.com/sissbruecker/linkding/pull/1020
* Accessibility improvements in page structure by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1014
* Improve announcements after navigation by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1015
* Fix OIDC login link by @cite in https://github.com/sissbruecker/linkding/pull/1019
* Fix bookmark asset download endpoint by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1033
* Add docs for auto tagging by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1009
* Fix typo in index.mdx tagline by @cenviity in https://github.com/sissbruecker/linkding/pull/1052
* Add how-to for using linkding PWA in native Android share sheet by @kzshantonu in https://github.com/sissbruecker/linkding/pull/1055
* Adding linktiles to community projects by @haondt in https://github.com/sissbruecker/linkding/pull/1025
* Bump django from 5.1.5 to 5.1.7 by @dependabot in https://github.com/sissbruecker/linkding/pull/1007
* Bump django from 5.1.7 to 5.1.8 by @dependabot in https://github.com/sissbruecker/linkding/pull/1030
* Bump tar-fs in /docs by @dependabot in https://github.com/sissbruecker/linkding/pull/1028
* Bump prismjs from 1.29.0 to 1.30.0 in /docs by @dependabot in https://github.com/sissbruecker/linkding/pull/1034
* Bump @babel/helpers from 7.26.7 to 7.27.0 in /docs by @dependabot in https://github.com/sissbruecker/linkding/pull/1035
* Bump vite from 5.4.14 to 5.4.17 in /docs by @dependabot in https://github.com/sissbruecker/linkding/pull/1036
* Bump esbuild, @astrojs/starlight and astro in /docs by @dependabot in https://github.com/sissbruecker/linkding/pull/1037
* Bump django from 5.1.8 to 5.1.9 by @dependabot in https://github.com/sissbruecker/linkding/pull/1059

### New Contributors
* @cite made their first contribution in https://github.com/sissbruecker/linkding/pull/1019
* @jose-elias-alvarez made their first contribution in https://github.com/sissbruecker/linkding/pull/1020
* @Teknicallity made their first contribution in https://github.com/sissbruecker/linkding/pull/999
* @haondt made their first contribution in https://github.com/sissbruecker/linkding/pull/1025
* @caycehouse made their first contribution in https://github.com/sissbruecker/linkding/pull/1024
* @cenviity made their first contribution in https://github.com/sissbruecker/linkding/pull/1052
* @sonicdoe made their first contribution in https://github.com/sissbruecker/linkding/pull/1051
* @jzorn made their first contribution in https://github.com/sissbruecker/linkding/pull/1058
* @dasrecht made their first contribution in https://github.com/sissbruecker/linkding/pull/1060

**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.39.1...v1.40.0

---

## v1.39.1 (06/03/2025)

> [!WARNING]
> Due to changes in the release process the `1.39.0` Docker image accidentally runs the application in debug mode. Please upgrade to `1.39.1` instead.

---

## v1.39.0 (06/03/2025)

### What's Changed
* Add REST endpoint for uploading snapshots from the Singlefile extension by @sissbruecker in https://github.com/sissbruecker/linkding/pull/996
* Add bookmark assets API by @sissbruecker in https://github.com/sissbruecker/linkding/pull/1003
* Allow providing REST API authentication token with Bearer keyword by @sissbruecker in https://github.com/sissbruecker/linkding/pull/995
* Add Telegram bot to community section by @marb08 in https://github.com/sissbruecker/linkding/pull/1001
* Adding linklater to community projects by @nsartor in https://github.com/sissbruecker/linkding/pull/1002

### New Contributors
* @marb08 made their first contribution in https://github.com/sissbruecker/linkding/pull/1001
* @nsartor made their first contribution in https://github.com/sissbruecker/linkding/pull/1002

**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.38.1...v1.39.0

---

## v1.38.1 (22/02/2025)

### What's Changed
* Remove preview image when bookmark is deleted by @sissbruecker in https://github.com/sissbruecker/linkding/pull/989
* Try limit uwsgi memory usage by configuring file descriptor limit by @sissbruecker in https://github.com/sissbruecker/linkding/pull/990
* Add note about OIDC and LD_SUPERUSER_NAME combination by @tebriel in https://github.com/sissbruecker/linkding/pull/992
* Return web archive fallback URL from REST API by @sissbruecker in https://github.com/sissbruecker/linkding/pull/993
* Fix auth proxy logout by @sissbruecker in https://github.com/sissbruecker/linkding/pull/994

### New Contributors
* @tebriel made their first contribution in https://github.com/sissbruecker/linkding/pull/992

**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.38.0...v1.38.1

---

## v1.38.0 (09/02/2025)

### What's Changed
* Fix nav menu closing on mousedown in Safari by @sissbruecker in https://github.com/sissbruecker/linkding/pull/965
* Allow customizing username when creating user through OIDC by @kyuuk in https://github.com/sissbruecker/linkding/pull/971
* Improve accessibility of modal dialogs by @sissbruecker in https://github.com/sissbruecker/linkding/pull/974
* Add option to collapse side panel by @sissbruecker in https://github.com/sissbruecker/linkding/pull/975
* Convert tag modal into drawer by @sissbruecker in https://github.com/sissbruecker/linkding/pull/977
* Add RSS link to shared bookmarks page by @sissbruecker in https://github.com/sissbruecker/linkding/pull/984
* Add Additional iOS Shortcut to community section by @joshdick in https://github.com/sissbruecker/linkding/pull/968

### New Contributors
* @kyuuk made their first contribution in https://github.com/sissbruecker/linkding/pull/971

**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.37.0...v1.38.0

---

## v1.37.0 (26/01/2025)

### What's Changed
* Add option to disable request logs by @dmarcoux in https://github.com/sissbruecker/linkding/pull/887
* Add default robots.txt to block crawlers by @sissbruecker in https://github.com/sissbruecker/linkding/pull/959
* Fix menu dropdown focus traps by @sissbruecker in https://github.com/sissbruecker/linkding/pull/944
* Provide accessible name to radio groups by @sissbruecker in https://github.com/sissbruecker/linkding/pull/945
* Add serchding to community projects, sort the list by alphabetical order by @ldwgchen in https://github.com/sissbruecker/linkding/pull/880
* Add cosmicding To Community Resources by @vkhitrin in https://github.com/sissbruecker/linkding/pull/892
* Add 3 new community projects by @sebw in https://github.com/sissbruecker/linkding/pull/949
* Add a rust client library to community.md by @zbrox in https://github.com/sissbruecker/linkding/pull/914
* Update community.md by @justusthane in https://github.com/sissbruecker/linkding/pull/897
* Bump astro from 4.15.8 to 4.16.3 in /docs by @dependabot in https://github.com/sissbruecker/linkding/pull/884
* Bump vite from 5.4.9 to 5.4.14 in /docs by @dependabot in https://github.com/sissbruecker/linkding/pull/953
* Bump django from 5.1.1 to 5.1.5 by @dependabot in https://github.com/sissbruecker/linkding/pull/947
* Bump nanoid from 3.3.7 to 3.3.8 by @dependabot in https://github.com/sissbruecker/linkding/pull/928
* Bump astro from 4.16.3 to 4.16.18 in /docs by @dependabot in https://github.com/sissbruecker/linkding/pull/929
* Bump nanoid from 3.3.7 to 3.3.8 in /docs by @dependabot in https://github.com/sissbruecker/linkding/pull/962

### New Contributors
* @ldwgchen made their first contribution in https://github.com/sissbruecker/linkding/pull/880
* @dmarcoux made their first contribution in https://github.com/sissbruecker/linkding/pull/887
* @vkhitrin made their first contribution in https://github.com/sissbruecker/linkding/pull/892
* @sebw made their first contribution in https://github.com/sissbruecker/linkding/pull/949
* @justusthane made their first contribution in https://github.com/sissbruecker/linkding/pull/897

**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.36.0...v1.37.0

---

## v1.36.0 (02/10/2024)

### What's Changed
* Replace uBlock Origin with uBlock Origin Lite by @sissbruecker in https://github.com/sissbruecker/linkding/pull/866
* Add LAST_MODIFIED attribute when exporting by @ixzhao in https://github.com/sissbruecker/linkding/pull/860
* Return client error status code for invalid form submissions by @sissbruecker in https://github.com/sissbruecker/linkding/pull/849
* Fix header.svg text by @vladh in https://github.com/sissbruecker/linkding/pull/850
* Do not clear fields in POST requests (API behavior change) by @sissbruecker in https://github.com/sissbruecker/linkding/pull/852
* Prevent duplicates when editing by @sissbruecker in https://github.com/sissbruecker/linkding/pull/853
* Fix jumping details modal on back navigation by @sissbruecker in https://github.com/sissbruecker/linkding/pull/854
* Fix select dropdown menu background in dark theme by @sissbruecker in https://github.com/sissbruecker/linkding/pull/858
* Do not escape valid characters in custom CSS by @sissbruecker in https://github.com/sissbruecker/linkding/pull/863
* Simplify Docker build by @sissbruecker in https://github.com/sissbruecker/linkding/pull/865
* Improve error handling for auto tagging by @sissbruecker in https://github.com/sissbruecker/linkding/pull/855
* Bump rollup from 4.13.0 to 4.22.4 by @dependabot in https://github.com/sissbruecker/linkding/pull/851
* Bump rollup from 4.21.3 to 4.22.4 in /docs by @dependabot in https://github.com/sissbruecker/linkding/pull/856

### New Contributors
* @vladh made their first contribution in https://github.com/sissbruecker/linkding/pull/850
* @ixzhao made their first contribution in https://github.com/sissbruecker/linkding/pull/860

**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.35.0...v1.36.0

---

## v1.35.0 (23/09/2024)

### What's Changed
* Add configuration options for pagination by @sissbruecker in https://github.com/sissbruecker/linkding/pull/835
* Show placeholder if there is no preview image by @sissbruecker in https://github.com/sissbruecker/linkding/pull/842
* Allow bookmarks to have empty title and description by @sissbruecker in https://github.com/sissbruecker/linkding/pull/843
* Add clear buttons in bookmark form by @sissbruecker in https://github.com/sissbruecker/linkding/pull/846
* Add basic fail2ban support by @sissbruecker in https://github.com/sissbruecker/linkding/pull/847
* Add documentation website by @sissbruecker in https://github.com/sissbruecker/linkding/pull/833
* Add go-linkding to community projects by @piero-vic in https://github.com/sissbruecker/linkding/pull/836
* Fix a broken link to options documentation by @zbrox in https://github.com/sissbruecker/linkding/pull/844
* Use HTTPS repository link for devcontainer by @voltagex in https://github.com/sissbruecker/linkding/pull/837
* Bump requests version to 3.23.3 by @voltagex in https://github.com/sissbruecker/linkding/pull/839
* Bump path-to-regexp and astro in /docs by @dependabot in https://github.com/sissbruecker/linkding/pull/840
* Bump dependencies by @sissbruecker in https://github.com/sissbruecker/linkding/pull/841

### New Contributors
* @piero-vic made their first contribution in https://github.com/sissbruecker/linkding/pull/836
* @voltagex made their first contribution in https://github.com/sissbruecker/linkding/pull/839
* @zbrox made their first contribution in https://github.com/sissbruecker/linkding/pull/844

**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.34.0...v1.35.0

---

## v1.34.0 (16/09/2024)

### What's Changed
* Fix several issues around browser back navigation by @sissbruecker in https://github.com/sissbruecker/linkding/pull/825
* Speed up response times for certain actions by @sissbruecker in https://github.com/sissbruecker/linkding/pull/829
* Implement IPv6 capability by @itz-Jana in https://github.com/sissbruecker/linkding/pull/826

### New Contributors
* @itz-Jana made their first contribution in https://github.com/sissbruecker/linkding/pull/826

**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.33.0...v1.34.0

---

## v1.33.0 (14/09/2024)

### What's Changed
* Theme improvements by @sissbruecker in https://github.com/sissbruecker/linkding/pull/822
* Speed up navigation by @sissbruecker in https://github.com/sissbruecker/linkding/pull/824
* Rename "SingeFileError" to "SingleFileError" by @curiousleo in https://github.com/sissbruecker/linkding/pull/823
* Bump svelte from 4.2.12 to 4.2.19 by @dependabot in https://github.com/sissbruecker/linkding/pull/806

### New Contributors
* @curiousleo made their first contribution in https://github.com/sissbruecker/linkding/pull/823

**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.32.0...v1.33.0

---

## v1.32.0 (10/09/2024)

### What's Changed
* Allow configuring landing page for unauthenticated users by @sissbruecker in https://github.com/sissbruecker/linkding/pull/808
* Allow configuring guest user profile by @sissbruecker in https://github.com/sissbruecker/linkding/pull/809
* Return bookmark tags in RSS feeds by @sissbruecker in https://github.com/sissbruecker/linkding/pull/810
* Additional filter parameters for RSS feeds by @sissbruecker in https://github.com/sissbruecker/linkding/pull/811
* Allow pre-filling notes in new bookmark form by @sissbruecker in https://github.com/sissbruecker/linkding/pull/812
* Fix inconsistent tag order in bookmarks by @sissbruecker in https://github.com/sissbruecker/linkding/pull/819
* Fix auto-tagging when URL includes port by @sissbruecker in https://github.com/sissbruecker/linkding/pull/820


**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.31.1...v1.32.0

---

## v1.31.1 (30/08/2024)

### What's Changed
* Include favicons and thumbnails in REST API by @sissbruecker in https://github.com/sissbruecker/linkding/pull/763
* Add Pinkt to the Community section by @fibelatti in https://github.com/sissbruecker/linkding/pull/772
* removed version line from docker compose yaml by @volumedata21 in https://github.com/sissbruecker/linkding/pull/800
* Add resource linkding logo by @QYG2297248353 in https://github.com/sissbruecker/linkding/pull/788
* Allow use of standard docker `TZ` env var by @watsonbox in https://github.com/sissbruecker/linkding/pull/765
* Add OCI source annotation to link back to source repo by @Ramblurr in https://github.com/sissbruecker/linkding/pull/701
* Generate fallback URLs for web archive links by @sissbruecker in https://github.com/sissbruecker/linkding/pull/804
* Fix overflow in settings page by @sissbruecker in https://github.com/sissbruecker/linkding/pull/805
* Bump django from 5.0.3 to 5.0.8 by @dependabot in https://github.com/sissbruecker/linkding/pull/795
* Bump certifi from 2023.11.17 to 2024.7.4 by @dependabot in https://github.com/sissbruecker/linkding/pull/775
* Bump djangorestframework from 3.14.0 to 3.15.2 by @dependabot in https://github.com/sissbruecker/linkding/pull/769
* Bump urllib3 from 2.1.0 to 2.2.2 by @dependabot in https://github.com/sissbruecker/linkding/pull/762

### New Contributors
* @fibelatti made their first contribution in https://github.com/sissbruecker/linkding/pull/772
* @volumedata21 made their first contribution in https://github.com/sissbruecker/linkding/pull/800
* @QYG2297248353 made their first contribution in https://github.com/sissbruecker/linkding/pull/788
* @watsonbox made their first contribution in https://github.com/sissbruecker/linkding/pull/765
* @Ramblurr made their first contribution in https://github.com/sissbruecker/linkding/pull/701

**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.31.0...v1.31.1

---

## v1.31.0 (16/06/2024)

### What's Changed
* Add support for bookmark thumbnails by @vslinko in https://github.com/sissbruecker/linkding/pull/721
* Automatically add tags to bookmarks based on URL pattern by @vslinko in https://github.com/sissbruecker/linkding/pull/736
* Load bookmark thumbnails after import by @vslinko in https://github.com/sissbruecker/linkding/pull/724
* Load missing thumbnails after enabling the feature by @sissbruecker in https://github.com/sissbruecker/linkding/pull/725
* Thumbnails lazy loading by @vslinko in https://github.com/sissbruecker/linkding/pull/734
* Add option for disabling tag grouping by @vslinko in https://github.com/sissbruecker/linkding/pull/735
* Preview auto tags in bookmark form by @sissbruecker in https://github.com/sissbruecker/linkding/pull/737
* Hide tooltip on mobile by @vslinko in https://github.com/sissbruecker/linkding/pull/733
* Bump requests from 2.31.0 to 2.32.0 by @dependabot in https://github.com/sissbruecker/linkding/pull/740

### New Contributors
* @vslinko made their first contribution in https://github.com/sissbruecker/linkding/pull/721

**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.30.0...v1.31.0

---

## v1.30.0 (20/04/2024)

### What's Changed
* Add reader mode by @sissbruecker in https://github.com/sissbruecker/linkding/pull/703
* Allow uploading custom files for bookmarks by @sissbruecker in https://github.com/sissbruecker/linkding/pull/713
* Add option for marking bookmarks as unread by default by @ab623 in https://github.com/sissbruecker/linkding/pull/706
* Make blocking cookie banners more reliable by @sissbruecker in https://github.com/sissbruecker/linkding/pull/699
* Close bookmark details with escape by @sissbruecker in https://github.com/sissbruecker/linkding/pull/702
* Show proper name for bookmark assets in admin by @ab623 in https://github.com/sissbruecker/linkding/pull/708
* Bump sqlparse from 0.4.4 to 0.5.0 by @dependabot in https://github.com/sissbruecker/linkding/pull/704

### New Contributors
* @ab623 made their first contribution in https://github.com/sissbruecker/linkding/pull/706

**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.29.0...v1.30.0

---

## v1.29.0 (14/04/2024)

### What's Changed
* Remove ads and cookie banners from HTML snapshots by @sissbruecker in https://github.com/sissbruecker/linkding/pull/695
* Add button for creating missing HTML snapshots by @sissbruecker in https://github.com/sissbruecker/linkding/pull/696
* Refresh file list when there are queued snapshots by @sissbruecker in https://github.com/sissbruecker/linkding/pull/697
* Bump idna from 3.6 to 3.7 by @dependabot in https://github.com/sissbruecker/linkding/pull/694


**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.28.0...v1.29.0

---

## v1.28.0 (09/04/2024)

### What's Changed
* Add option to disable SSL verification for OIDC by @akaSyntaax in https://github.com/sissbruecker/linkding/pull/684
* Add full backup method by @sissbruecker in https://github.com/sissbruecker/linkding/pull/686
* Truncate snapshot filename for long URLs by @sissbruecker in https://github.com/sissbruecker/linkding/pull/687
* Add option for customizing single-file timeout by @pettijohn in https://github.com/sissbruecker/linkding/pull/688
* Add option for passing arguments to single-file command by @pettijohn in https://github.com/sissbruecker/linkding/pull/691
* Fix typo by @tianheg in https://github.com/sissbruecker/linkding/pull/689

### New Contributors
* @akaSyntaax made their first contribution in https://github.com/sissbruecker/linkding/pull/684
* @pettijohn made their first contribution in https://github.com/sissbruecker/linkding/pull/688

**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.27.1...v1.28.0

---

## v1.27.1 (07/04/2024)

### What's Changed
* Fix HTML snapshot errors related to single-file-cli by @sissbruecker in https://github.com/sissbruecker/linkding/pull/683
* Replace django-background-tasks with huey by @sissbruecker in https://github.com/sissbruecker/linkding/pull/657
* Add Authelia OIDC example to docs by @hugo-vrijswijk in https://github.com/sissbruecker/linkding/pull/675


**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.27.0...v1.27.1

---

## v1.27.0 (01/04/2024)

### What's Changed
* Archive snapshots of websites locally by @sissbruecker in https://github.com/sissbruecker/linkding/pull/672
* Add Railway hosting option by @tianheg in https://github.com/sissbruecker/linkding/pull/661
* Add how to for increasing the font size by @sissbruecker in https://github.com/sissbruecker/linkding/pull/667

### New Contributors
* @tianheg made their first contribution in https://github.com/sissbruecker/linkding/pull/661

**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.26.0...v1.27.0

---

## v1.26.0 (30/03/2024)

### What's Changed
* Add option for showing bookmark description as separate block by @sissbruecker in https://github.com/sissbruecker/linkding/pull/663
* Add bookmark details view by @sissbruecker in https://github.com/sissbruecker/linkding/pull/665
* Make bookmark list actions configurable by @sissbruecker in https://github.com/sissbruecker/linkding/pull/666
* Bump black from 24.1.1 to 24.3.0 by @dependabot in https://github.com/sissbruecker/linkding/pull/662


**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.25.0...v1.26.0

---

## v1.25.0 (18/03/2024)

### What's Changed
* Improve PWA capabilities by @hugo-vrijswijk in https://github.com/sissbruecker/linkding/pull/630
* build improvements by @hugo-vrijswijk in https://github.com/sissbruecker/linkding/pull/649
* Add support for oidc by @Nighmared in https://github.com/sissbruecker/linkding/pull/389
* Add option for custom CSS by @sissbruecker in https://github.com/sissbruecker/linkding/pull/652
* Update backup location to safe directory by @bphenriques in https://github.com/sissbruecker/linkding/pull/653
* Include web archive link in /api/bookmarks/ by @sissbruecker in https://github.com/sissbruecker/linkding/pull/655
* Add RSS feeds for shared bookmarks by @sissbruecker in https://github.com/sissbruecker/linkding/pull/656
* Bump django from 5.0.2 to 5.0.3 by @dependabot in https://github.com/sissbruecker/linkding/pull/658

### New Contributors
* @hugo-vrijswijk made their first contribution in https://github.com/sissbruecker/linkding/pull/630
* @Nighmared made their first contribution in https://github.com/sissbruecker/linkding/pull/389
* @bphenriques made their first contribution in https://github.com/sissbruecker/linkding/pull/653

**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.24.2...v1.25.0

---

## v1.24.2 (16/03/2024)

### What's Changed
* Fix logout button by @sissbruecker in https://github.com/sissbruecker/linkding/pull/648


**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.24.1...v1.24.2

---

## v1.24.1 (16/03/2024)

### What's Changed
* Bump dependencies by @sissbruecker in https://github.com/sissbruecker/linkding/pull/618
* Persist secret key in data folder by @sissbruecker in https://github.com/sissbruecker/linkding/pull/620
* Group ideographic characters in tag cloud by @jonathan-s in https://github.com/sissbruecker/linkding/pull/613
* Bump django from 5.0.1 to 5.0.2 by @dependabot in https://github.com/sissbruecker/linkding/pull/625
* Add k8s setup to community section by @jzck in https://github.com/sissbruecker/linkding/pull/633
* Added a new Linkding client to community section by @JGeek00 in https://github.com/sissbruecker/linkding/pull/638

### New Contributors
* @jzck made their first contribution in https://github.com/sissbruecker/linkding/pull/633
* @JGeek00 made their first contribution in https://github.com/sissbruecker/linkding/pull/638

**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.24.0...v1.24.1

---

## v1.24.0 (27/01/2024)

### What's Changed
* Support Open Graph description by @jonathan-s in https://github.com/sissbruecker/linkding/pull/602
* Add tooltip to truncated bookmark titles by @jonathan-s in https://github.com/sissbruecker/linkding/pull/607
* Improve bulk tag performance by @sissbruecker in https://github.com/sissbruecker/linkding/pull/612
* Increase tag limit in tag autocomplete by @hypebeast in https://github.com/sissbruecker/linkding/pull/581
* Add CapRover as managed hosting option by @adamshand in https://github.com/sissbruecker/linkding/pull/585
* Bump playwright dependencies by @jonathan-s in https://github.com/sissbruecker/linkding/pull/601
* Adjust archive.org donation link in general.html by @JnsDornbusch in https://github.com/sissbruecker/linkding/pull/603

### New Contributors
* @hypebeast made their first contribution in https://github.com/sissbruecker/linkding/pull/581
* @adamshand made their first contribution in https://github.com/sissbruecker/linkding/pull/585
* @jonathan-s made their first contribution in https://github.com/sissbruecker/linkding/pull/601
* @JnsDornbusch made their first contribution in https://github.com/sissbruecker/linkding/pull/603

**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.23.1...v1.24.0

---

## v1.23.1 (08/12/2023)

### What's Changed
* Properly encode search query param by @sissbruecker in https://github.com/sissbruecker/linkding/pull/587

> [!WARNING] 
> *This resolves a security vulnerability in linkding. Everyone is encouraged to upgrade to the latest version as soon as possible.*

**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.23.0...v1.23.1

---

## v1.23.0 (24/11/2023)

### What's Changed
* Add Alpine based Docker image (experimental) by @sissbruecker in https://github.com/sissbruecker/linkding/pull/570
* Add backup CLI command by @sissbruecker in https://github.com/sissbruecker/linkding/pull/571
* Update browser extension links by @OPerepadia in https://github.com/sissbruecker/linkding/pull/574
* Include archived bookmarks in export by @sissbruecker in https://github.com/sissbruecker/linkding/pull/579

### New Contributors
* @OPerepadia made their first contribution in https://github.com/sissbruecker/linkding/pull/574

**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.22.3...v1.23.0

---

## v1.22.3 (04/11/2023)

### What's Changed
* Fix RSS feed not handling None values  by @vitormarcal in https://github.com/sissbruecker/linkding/pull/569
* Bump django from 4.1.10 to 4.1.13 by @dependabot in https://github.com/sissbruecker/linkding/pull/567

### New Contributors
* @vitormarcal made their first contribution in https://github.com/sissbruecker/linkding/pull/569

**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.22.2...v1.22.3

---

## v1.22.2 (27/10/2023)

### What's Changed
* Fix search options not opening on iOS by @sissbruecker in https://github.com/sissbruecker/linkding/pull/549
* Bump urllib3 from 1.26.11 to 1.26.17 by @dependabot in https://github.com/sissbruecker/linkding/pull/542
* Add iOS shortcut to community section by @andrewdolphin in https://github.com/sissbruecker/linkding/pull/550
* Disable editing of search preferences in user admin by @sissbruecker in https://github.com/sissbruecker/linkding/pull/555
* Add feed2linkding to community section by @Strubbl in https://github.com/sissbruecker/linkding/pull/544
* Sanitize RSS feed to remove control characters by @sissbruecker in https://github.com/sissbruecker/linkding/pull/565
* Bump urllib3 from 1.26.17 to 1.26.18 by @dependabot in https://github.com/sissbruecker/linkding/pull/560

### New Contributors
* @andrewdolphin made their first contribution in https://github.com/sissbruecker/linkding/pull/550
* @Strubbl made their first contribution in https://github.com/sissbruecker/linkding/pull/544

**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.22.1...v1.22.2

---

## v1.22.1 (06/10/2023)

### What's Changed
* Fix memory leak with SQLite by @sissbruecker in https://github.com/sissbruecker/linkding/pull/548


**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.22.0...v1.22.1

---

## v1.22.0 (01/10/2023)

### What's Changed
* Fix case-insensitive search for unicode characters in SQLite by @sissbruecker in https://github.com/sissbruecker/linkding/pull/520
* Add sort option to bookmark list by @sissbruecker in https://github.com/sissbruecker/linkding/pull/522
* Add button to show tags on smaller screens by @sissbruecker in https://github.com/sissbruecker/linkding/pull/529
* Make code blocks in notes scrollable by @sissbruecker in https://github.com/sissbruecker/linkding/pull/530
* Add filter for shared state by @sissbruecker in https://github.com/sissbruecker/linkding/pull/531
* Add support for exporting/importing bookmark notes by @sissbruecker in https://github.com/sissbruecker/linkding/pull/532
* Add filter for unread state by @sissbruecker in https://github.com/sissbruecker/linkding/pull/535
* Allow saving search preferences by @sissbruecker in https://github.com/sissbruecker/linkding/pull/540
* Add user profile endpoint by @sissbruecker in https://github.com/sissbruecker/linkding/pull/541


**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.21.0...v1.22.0

---

## v1.21.1 (26/09/2023)

### What's Changed
* Fix bulk edit to respect searched tags by @sissbruecker in https://github.com/sissbruecker/linkding/pull/537


**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.21.0...v1.21.1

---

## v1.21.0 (25/08/2023)

### What's Changed
* Make search autocomplete respect link target setting by @sissbruecker in https://github.com/sissbruecker/linkding/pull/513
* Various CSS improvements by @sissbruecker in https://github.com/sissbruecker/linkding/pull/514
* Display shared state in bookmark list by @sissbruecker in https://github.com/sissbruecker/linkding/pull/515
* Allow bulk editing unread and shared state of bookmarks by @sissbruecker in https://github.com/sissbruecker/linkding/pull/517
* Bump uwsgi from 2.0.20 to 2.0.22 by @dependabot in https://github.com/sissbruecker/linkding/pull/516


**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.20.1...v1.21.0

---

## v1.20.1 (23/08/2023)

### What's Changed
* Update cached styles and scripts after version change by @sissbruecker in https://github.com/sissbruecker/linkding/pull/510


**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.20.0...v1.20.1

---

## v1.20.0 (22/08/2023)

### What's Changed
* Add option to share bookmarks publicly by @sissbruecker in https://github.com/sissbruecker/linkding/pull/503
* Various improvements to favicons by @sissbruecker in https://github.com/sissbruecker/linkding/pull/504
* Add support for PRIVATE flag in import and export by @sissbruecker in https://github.com/sissbruecker/linkding/pull/505
* Avoid page reload when triggering actions in bookmark list by @sissbruecker in https://github.com/sissbruecker/linkding/pull/506


**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.19.1...v1.20.0

---

## v1.19.1 (29/07/2023)

### What's Changed
* Add Postman Collection to Community section of README by @gingerbeardman in https://github.com/sissbruecker/linkding/pull/476
* Added Dev Container support by @acbgbca in https://github.com/sissbruecker/linkding/pull/474
* Added Apple web-app meta tag #358 by @acbgbca in https://github.com/sissbruecker/linkding/pull/359
* Bump requests from 2.28.1 to 2.31.0 by @dependabot in https://github.com/sissbruecker/linkding/pull/478
* Allow passing title and description to new bookmark form by @acbgbca in https://github.com/sissbruecker/linkding/pull/479
* Enable WAL to avoid locked database lock errors by @sissbruecker in https://github.com/sissbruecker/linkding/pull/480
* Fix website loader content encoding detection by @sissbruecker in https://github.com/sissbruecker/linkding/pull/482
* Bump certifi from 2022.12.7 to 2023.7.22 by @dependabot in https://github.com/sissbruecker/linkding/pull/497
* Bump django from 4.1.9 to 4.1.10 by @dependabot in https://github.com/sissbruecker/linkding/pull/494

### New Contributors
* @gingerbeardman made their first contribution in https://github.com/sissbruecker/linkding/pull/476
* @acbgbca made their first contribution in https://github.com/sissbruecker/linkding/pull/474

**Full Changelog**: https://github.com/sissbruecker/linkding/compare/v1.19.0...v1.19.1

---

## 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

**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

**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 external redirects

---

## v1.8.7 (26/03/2022)

- [**bug**] Increase request buffer size [#28](https://github.com/sissbruecker/linkding/issues/28)
- [**enhancement**]  Allow specifying port through LINKDING_PORT environment variable [#156](https://github.com/sissbruecker/linkding/pull/156)
- [**chore**] Bump NPM packages [#224](https://github.com/sissbruecker/linkding/pull/224)

---

## v1.8.6 (25/03/2022)

- [bug] fix bookmark access restrictions
- [bug] prevent external redirects
- [chore] bump dependencies

---

## v1.8.5 (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)
  - allows to press `s` to focus the search input

---

## v1.8.0 (04/09/2021)

- [**enhancement**] Wayback Machine Integration [#59](https://github.com/sissbruecker/linkding/issues/59)
  - Automatically creates snapshots of bookmarked websites on [web archive](https://archive.org/web/)
  - This is one of the largest changes yet and adds a task processor that runs as a separate process in the background. If you run into issues with this feature, it can be disabled using the [LD_DISABLE_BACKGROUND_TASKS](https://github.com/sissbruecker/linkding/blob/master/docs/Options.md#ld_disable_background_tasks) option

---

## v1.7.2 (26/08/2021)

- [**enhancement**] Add support for nanosecond resolution timestamps for bookmark import (e.g. Google Bookmarks) [#146](https://github.com/sissbruecker/linkding/issues/146)

---

## v1.7.1 (25/08/2021)

- [**bug**] umlaut/non-ascii characters broken when using bookmarklet (firefox) [#148](https://github.com/sissbruecker/linkding/issues/148)
- [**bug**] Bookmark import accepts empty URL values [#124](https://github.com/sissbruecker/linkding/issues/124)
- [**enhancement**] Show the version in the settings [#104](https://github.com/sissbruecker/linkding/issues/104)

---

## v1.7.0 (17/08/2021)

- Upgrade to Django 3
- Bump other dependencies

---

## v1.6.5 (15/08/2021)

- [**enhancement**] query with multiple hashtags very slow [#112](https://github.com/sissbruecker/linkding/issues/112)

---

## v1.6.4 (13/05/2021)

- Update dependencies for security fixes

---

## v1.6.3 (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)
- [**enhancement**] Make scraped title and description editable [#80](https://github.com/sissbruecker/linkding/issues/80)

---

## v1.6.1 (31/03/2021)

- Expose date_added in UI [#85](https://github.com/sissbruecker/linkding/issues/85)

---

## v1.6.0 (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
- Documentation improvements

---

## v1.4.0 (24/02/2021)

- [**enhancement**] Improve admin utilization [#76](https://github.com/sissbruecker/linkding/issues/76)

---

## v1.3.3 (18/02/2021)

- [**closed**] Missing "description" request body parameter in API causes 500 [#78](https://github.com/sissbruecker/linkding/issues/78)

---

## v1.3.2 (18/02/2021)

- [**closed**] /archive and /unarchive API routes return 404 [#77](https://github.com/sissbruecker/linkding/issues/77)
- [**closed**] API - /api/check_url?url= with token authetification [#55](https://github.com/sissbruecker/linkding/issues/55)

---

## v1.3.1 (15/02/2021)

[enhancement] Enhance delete links with inline confirmation

---

## v1.3.0 (14/02/2021)

- [**closed**] Novice help. [#71](https://github.com/sissbruecker/linkding/issues/71)
- [**closed**] Option to create bookmarks public [#70](https://github.com/sissbruecker/linkding/issues/70)
- [**enhancement**] Show URL if title is not available [#64](https://github.com/sissbruecker/linkding/issues/64)
- [**bug**] minor ui nitpicks [#62](https://github.com/sissbruecker/linkding/issues/62)
- [**enhancement**] add an archive function [#46](https://github.com/sissbruecker/linkding/issues/46)
- [**closed**] remove non fqdn check and alert [#36](https://github.com/sissbruecker/linkding/issues/36)
- [**closed**] Add Lotus Notes links [#22](https://github.com/sissbruecker/linkding/issues/22)

---

## v1.2.1 (12/01/2021)

- [**bug**] Bug: Two equal tags with different capitalisation lead to 500 server errors [#65](https://github.com/sissbruecker/linkding/issues/65)
- [**closed**] Enhancement: category and pagination [#11](https://github.com/sissbruecker/linkding/issues/11)

---

## 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)

---

## 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)

================================================
FILE: LICENSE.txt
================================================
The MIT License (MIT)

Copyright (c) 2019 Sascha Ißbrücker

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

================================================
FILE: Makefile
================================================
.PHONY: serve

init:
	uv sync
	[ -d data ] || mkdir data data/assets data/favicons data/previews
	uv run manage.py migrate
	npm install

serve:
	uv run manage.py runserver

tasks:
	uv run manage.py run_huey

test:
	uv run pytest -n auto

lint:
	uv run ruff check bookmarks

format:
	uv run ruff format bookmarks
	uv run djlint bookmarks/templates --reformat --quiet --warn
	npx prettier bookmarks/frontend --write
	npx prettier bookmarks/styles --write

prepare-e2e:
	uv run playwright install chromium
	rm -rf static
	npm run build
	uv run manage.py collectstatic --no-input

e2e:
	make prepare-e2e
	uv run pytest bookmarks/tests_e2e -n auto -o "python_files=e2e_test_*.py"

frontend:
	npm run dev


================================================
FILE: README.md
================================================
<div align="center">
    <br>
    <a href="https://github.com/sissbruecker/linkding">
        <img src="assets/header.svg" height="50">
    </a>
    <br>
</div>

##  Introduction

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:
- *link* which is often used as a synonym for URLs and bookmarks in common language
- *Ding* which is German for thing
- ...so basically something for managing your links

**Feature Overview:**
- Clean UI optimized for readability
- Organize bookmarks with tags
- Bulk editing, Markdown notes, read it later functionality
- Share bookmarks with other users or guests
- Automatically provides titles, descriptions and icons of bookmarked websites
- Automatically archive websites, either as local HTML file or on Internet Archive
- Import and export bookmarks in Netscape HTML format
- Installable as a Progressive Web App (PWA)
- Extensions for [Firefox](https://addons.mozilla.org/firefox/addon/linkding-extension/) and [Chrome](https://chrome.google.com/webstore/detail/linkding-extension/beakmhbijpdhipnjhnclmhgjlddhidpe), as well as a bookmarklet
- SSO support via OIDC or authentication proxies
- REST API for developing 3rd party apps
- Admin panel for user self-service and raw data access


**Demo:** https://demo.linkding.link/

**Screenshot:**

![Screenshot](/docs/public/linkding-screenshot.png?raw=true "Screenshot")

## Getting Started

The following links help you to get started with linkding:
- [Install linkding on your own server](https://linkding.link/installation) or [check managed hosting options](https://linkding.link/managed-hosting)
- [Install the browser extension](https://linkding.link/browser-extension)
- [Check out community projects](https://linkding.link/community), which include mobile apps, browser extensions, libraries and more

## Documentation

The full documentation is now available at [linkding.link](https://linkding.link/).

If you want to contribute to the documentation, you can find the source files in the `docs` folder.

If you want to contribute a community project, feel free to [submit a PR](https://github.com/sissbruecker/linkding/edit/master/docs/src/content/docs/community.md).

## Contributing

Small improvements, bugfixes and documentation improvements are always welcome. If you want to contribute a larger feature, consider opening an issue first to discuss it. I may choose to ignore PRs for features that don't align with the project's goals or that I don't want to maintain.

## Development

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. Other than that the code should be self-explanatory / standard Django stuff 🙂.

### Prerequisites
- Python 3.13
- [uv](https://docs.astral.sh/uv/getting-started/installation/)
- Node.js

### Setup

Initialize the development environment with:
```
make init
```
This sets up a virtual environment using uv, installs NPM dependencies and runs migrations to create the initial database.

Create a user for the frontend:
```
uv run manage.py createsuperuser --username=joe --email=joe@example.com
```

Run the frontend build for bundling frontend components with:
```
make frontend
```

Then start the Django development server with:
```
make serve
```
The frontend is now available under http://localhost:8000

### Tests

Run all tests with pytest:
```
make test
```


### Linting

Run linting with ruff:
```
make lint
```

### Formatting

Format Python code with ruff, Django templates with djlint, and JavaScript code with prettier:
```
make format
```

### 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=https://github.com/sissbruecker/linkding.git)

Once checked out, only the following commands are required to get started:

Create a user for the frontend:
```
uv run 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:
```
make frontend
```
Start the Django development server with:
```
make serve
```
The frontend is now available under http://localhost:8000


================================================
FILE: SECURITY.md
================================================
# Security Policy

## Supported Versions

| Version | Supported          |
| ------- | ------------------ |
| 1.10.x   | :white_check_mark: |

## Reporting a Vulnerability

To report a vulnerability, please send a mail to: 588ex5zl8@mozmail.com

I'll try to get back to you as soon as possible.


================================================
FILE: bookmarks/__init__.py
================================================


================================================
FILE: bookmarks/admin.py
================================================
import os

from django import forms
from django.contrib import admin, messages
from django.contrib.admin import AdminSite
from django.contrib.auth.admin import UserAdmin
from django.contrib.auth.models import User
from django.core.paginator import Paginator
from django.db.models import Count, QuerySet
from django.shortcuts import render
from django.urls import path
from django.utils.translation import gettext, ngettext
from huey.contrib.djhuey import HUEY as huey

from bookmarks.models import (
    ApiToken,
    Bookmark,
    BookmarkAsset,
    BookmarkBundle,
    FeedToken,
    Tag,
    Toast,
    UserProfile,
)
from bookmarks.services.bookmarks import archive_bookmark, unarchive_bookmark


# Custom paginator to paginate through Huey tasks
class TaskPaginator(Paginator):
    def __init__(self):
        super().__init__(self, 100)
        self.task_count = huey.storage.queue_size()

    @property
    def count(self):
        return self.task_count

    def page(self, number):
        limit = self.per_page
        offset = (number - 1) * self.per_page
        return self._get_page(
            self.enqueued_items(limit, offset),
            number,
            self,
        )

    # Copied from Huey's SqliteStorage with some modifications to allow pagination
    def enqueued_items(self, limit, offset):
        def to_bytes(b):
            return bytes(b) if not isinstance(b, bytes) else b

        sql = "select data from task where queue=? order by priority desc, id limit ? offset ?"
        params = (huey.storage.name, limit, offset)

        serialized_tasks = [
            to_bytes(i) for (i,) in huey.storage.sql(sql, params, results=True)
        ]
        return [huey.deserialize_task(task) for task in serialized_tasks]


# Custom view to display Huey tasks in the admin
def background_task_view(request):
    page_number = int(request.GET.get("p", 1))
    paginator = TaskPaginator()
    page = paginator.get_page(page_number)
    page_range = paginator.get_elided_page_range(page_number, on_each_side=2, on_ends=2)
    context = {
        **linkding_admin_site.each_context(request),
        "title": "Background tasks",
        "page": page,
        "page_range": page_range,
        "tasks": page.object_list,
    }
    return render(request, "admin/background_tasks.html", context)


class LinkdingAdminSite(AdminSite):
    site_header = "linkding administration"
    site_title = "linkding Admin"

    def get_urls(self):
        urls = super().get_urls()
        custom_urls = [
            path("tasks/", background_task_view, name="background_tasks"),
        ]
        return custom_urls + urls

    def get_app_list(self, request, app_label=None):
        app_list = super().get_app_list(request, app_label)
        context_path = os.getenv("LD_CONTEXT_PATH", "")
        app_list += [
            {
                "name": "Huey",
                "app_label": "huey_app",
                "models": [
                    {
                        "name": "Queued tasks",
                        "object_name": "background_tasks",
                        "admin_url": f"/{context_path}admin/tasks/",
                        "view_only": True,
                    }
                ],
            }
        ]
        return app_list


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",
        "unread",
        "tags",
    )
    ordering = ("-date_added",)
    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:
            archive_bookmark(bookmark)
        bookmarks_count = queryset.count()
        self.message_user(
            request,
            ngettext(
                "%d bookmark was successfully archived.",
                "%d bookmarks were successfully archived.",
                bookmarks_count,
            )
            % bookmarks_count,
            messages.SUCCESS,
        )

    def unarchive_selected_bookmarks(self, request, queryset: QuerySet):
        for bookmark in queryset:
            unarchive_bookmark(bookmark)
        bookmarks_count = queryset.count()
        self.message_user(
            request,
            ngettext(
                "%d bookmark was successfully unarchived.",
                "%d bookmarks were successfully unarchived.",
                bookmarks_count,
            )
            % bookmarks_count,
            messages.SUCCESS,
        )

    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 AdminBookmarkAsset(admin.ModelAdmin):
    @admin.display(description="Display Name")
    def custom_display_name(self, obj):
        return str(obj)

    list_display = ("custom_display_name", "date_created", "status")
    search_fields = (
        "display_name",
        "file",
    )
    list_filter = ("status",)


class AdminTag(admin.ModelAdmin):
    list_display = ("name", "bookmarks_count", "owner", "date_added")
    search_fields = ("name", "owner__username")
    list_filter = ("owner__username",)
    ordering = ("-date_added",)
    actions = ["delete_unused_tags"]

    def get_queryset(self, request):
        queryset = super().get_queryset(request)
        queryset = queryset.annotate(bookmarks_count=Count("bookmark"))
        return queryset

    def bookmarks_count(self, obj):
        return obj.bookmarks_count

    bookmarks_count.admin_order_field = "bookmarks_count"

    def delete_unused_tags(self, request, queryset: QuerySet):
        unused_tags = queryset.filter(bookmark__isnull=True)
        unused_tags_count = unused_tags.count()
        for tag in unused_tags:
            tag.delete()

        if unused_tags_count > 0:
            self.message_user(
                request,
                ngettext(
                    "%d unused tag was successfully deleted.",
                    "%d unused tags were successfully deleted.",
                    unused_tags_count,
                )
                % unused_tags_count,
                messages.SUCCESS,
            )
        else:
            self.message_user(
                request,
                gettext(
                    "There were no unused tags in the selection",
                ),
                messages.SUCCESS,
            )


class AdminBookmarkBundle(admin.ModelAdmin):
    list_display = (
        "name",
        "owner",
        "order",
        "search",
        "any_tags",
        "all_tags",
        "excluded_tags",
        "filter_shared",
        "filter_unread",
        "date_created",
    )
    search_fields = ["name", "search", "any_tags", "all_tags", "excluded_tags"]
    list_filter = ("owner__username",)


class AdminUserProfileInline(admin.StackedInline):
    model = UserProfile
    can_delete = False
    verbose_name_plural = "Profile"
    fk_name = "user"
    readonly_fields = ("search_preferences",)


class AdminCustomUser(UserAdmin):
    inlines = (AdminUserProfileInline,)

    def get_inline_instances(self, request, obj=None):
        if not obj:
            return list()
        return super().get_inline_instances(request, obj)


class AdminToast(admin.ModelAdmin):
    list_display = ("key", "message", "owner", "acknowledged")
    search_fields = ("key", "message")
    list_filter = ("owner__username",)


class AdminFeedToken(admin.ModelAdmin):
    list_display = ("key", "user")
    search_fields = ["key"]
    list_filter = ("user__username",)


class ApiTokenAdminForm(forms.ModelForm):
    class Meta:
        model = ApiToken
        fields = ("name", "user")


class AdminApiToken(admin.ModelAdmin):
    form = ApiTokenAdminForm
    list_display = ("name", "user", "created")
    search_fields = ["name", "user__username"]
    list_filter = ("user__username",)
    ordering = ("-created",)


linkding_admin_site = LinkdingAdminSite()
linkding_admin_site.register(Bookmark, AdminBookmark)
linkding_admin_site.register(BookmarkAsset, AdminBookmarkAsset)
linkding_admin_site.register(Tag, AdminTag)
linkding_admin_site.register(BookmarkBundle, AdminBookmarkBundle)
linkding_admin_site.register(User, AdminCustomUser)
linkding_admin_site.register(ApiToken, AdminApiToken)
linkding_admin_site.register(Toast, AdminToast)
linkding_admin_site.register(FeedToken, AdminFeedToken)


================================================
FILE: bookmarks/api/__init__.py
================================================


================================================
FILE: bookmarks/api/auth.py
================================================
from django.utils.translation import gettext_lazy as _
from rest_framework import exceptions
from rest_framework.authentication import TokenAuthentication, get_authorization_header

from bookmarks.models import ApiToken


class LinkdingTokenAuthentication(TokenAuthentication):
    """
    Extends DRF TokenAuthentication to add support for multiple keywords and
    multiple tokens per user.
    """

    model = ApiToken
    keywords = [keyword.lower().encode() for keyword in ["Token", "Bearer"]]

    def authenticate(self, request):
        auth = get_authorization_header(request).split()

        if not auth or auth[0].lower() not in self.keywords:
            return None

        if len(auth) == 1:
            msg = _("Invalid token header. No credentials provided.")
            raise exceptions.AuthenticationFailed(msg)
        elif len(auth) > 2:
            msg = _("Invalid token header. Token string should not contain spaces.")
            raise exceptions.AuthenticationFailed(msg)

        try:
            token = auth[1].decode()
        except UnicodeError:
            msg = _(
                "Invalid token header. Token string should not contain invalid characters."
            )
            raise exceptions.AuthenticationFailed(msg) from None

        return self.authenticate_credentials(token)


================================================
FILE: bookmarks/api/routes.py
================================================
import gzip
import logging
import os

from django.conf import settings
from django.http import Http404, StreamingHttpResponse
from rest_framework import mixins, status, viewsets
from rest_framework.decorators import action
from rest_framework.permissions import AllowAny
from rest_framework.response import Response
from rest_framework.routers import DefaultRouter, SimpleRouter

from bookmarks import queries
from bookmarks.api.serializers import (
    BookmarkAssetSerializer,
    BookmarkBundleSerializer,
    BookmarkSerializer,
    TagSerializer,
    UserProfileSerializer,
)
from bookmarks.models import (
    Bookmark,
    BookmarkAsset,
    BookmarkBundle,
    BookmarkSearch,
    Tag,
    User,
)
from bookmarks.services import assets, auto_tagging, bookmarks, bundles, website_loader
from bookmarks.type_defs import HttpRequest
from bookmarks.views import access

logger = logging.getLogger(__name__)


class BookmarkViewSet(
    viewsets.GenericViewSet,
    mixins.ListModelMixin,
    mixins.RetrieveModelMixin,
    mixins.CreateModelMixin,
    mixins.UpdateModelMixin,
    mixins.DestroyModelMixin,
):
    request: HttpRequest
    serializer_class = BookmarkSerializer

    def get_permissions(self):
        # Allow unauthenticated access to shared bookmarks.
        # The shared action should still filter bookmarks so that
        # unauthenticated users only see bookmarks from users that have public
        # sharing explicitly enabled
        if self.action == "shared":
            return [AllowAny()]

        # Otherwise use default permissions which should require authentication
        return super().get_permissions()

    def get_queryset(self):
        # Provide filtered queryset for list actions
        user = self.request.user
        search = BookmarkSearch.from_request(self.request, self.request.GET)
        if self.action == "list":
            return queries.query_bookmarks(user, user.profile, search)
        elif self.action == "archived":
            return queries.query_archived_bookmarks(user, user.profile, search)
        elif self.action == "shared":
            user = User.objects.filter(username=search.user).first()
            public_only = not self.request.user.is_authenticated
            return queries.query_shared_bookmarks(
                user, self.request.user_profile, search, public_only
            )

        # For single entity actions return user owned bookmarks
        return Bookmark.objects.all().filter(owner=user)

    def get_serializer_context(self):
        disable_scraping = "disable_scraping" in self.request.GET
        disable_html_snapshot = "disable_html_snapshot" in self.request.GET
        return {
            "request": self.request,
            "user": self.request.user,
            "disable_scraping": disable_scraping,
            "disable_html_snapshot": disable_html_snapshot,
        }

    @action(methods=["get"], detail=False)
    def archived(self, request: HttpRequest):
        return self.list(request)

    @action(methods=["get"], detail=False)
    def shared(self, request: HttpRequest):
        return self.list(request)

    @action(methods=["post"], detail=True)
    def archive(self, request: HttpRequest, pk):
        bookmark = self.get_object()
        bookmarks.archive_bookmark(bookmark)
        return Response(status=status.HTTP_204_NO_CONTENT)

    @action(methods=["post"], detail=True)
    def unarchive(self, request: HttpRequest, pk):
        bookmark = self.get_object()
        bookmarks.unarchive_bookmark(bookmark)
        return Response(status=status.HTTP_204_NO_CONTENT)

    @action(methods=["get"], detail=False)
    def check(self, request: HttpRequest):
        url = request.GET.get("url")
        ignore_cache = request.GET.get("ignore_cache", False) in ["true"]
        bookmark = Bookmark.query_existing(request.user, url).first()
        existing_bookmark_data = (
            self.get_serializer(bookmark).data if bookmark else None
        )

        metadata = website_loader.load_website_metadata(url, ignore_cache=ignore_cache)

        # Return tags that would be automatically applied to the bookmark
        profile = request.user.profile
        auto_tags = []
        if profile.auto_tagging_rules:
            try:
                auto_tags = auto_tagging.get_tags(profile.auto_tagging_rules, url)
            except Exception as e:
                logger.error(
                    f"Failed to auto-tag bookmark. url={url}",
                    exc_info=e,
                )

        return Response(
            {
                "bookmark": existing_bookmark_data,
                "metadata": metadata.to_dict(),
                "auto_tags": auto_tags,
            },
            status=status.HTTP_200_OK,
        )

    @action(methods=["post"], detail=False)
    def singlefile(self, request: HttpRequest):
        if settings.LD_DISABLE_ASSET_UPLOAD:
            return Response(
                {"error": "Asset upload is disabled."},
                status=status.HTTP_403_FORBIDDEN,
            )
        url = request.POST.get("url")
        file = request.FILES.get("file")

        if not url or not file:
            return Response(
                {"error": "Both 'url' and 'file' parameters are required."},
                status=status.HTTP_400_BAD_REQUEST,
            )

        bookmark = Bookmark.query_existing(request.user, url).first()

        if not bookmark:
            bookmark = Bookmark(url=url)
            bookmark = bookmarks.create_bookmark(
                bookmark, "", request.user, disable_html_snapshot=True
            )
            bookmarks.enhance_with_website_metadata(bookmark)

        assets.upload_snapshot(bookmark, file.read())

        return Response(
            {"message": "Snapshot uploaded successfully."},
            status=status.HTTP_201_CREATED,
        )


class BookmarkAssetViewSet(
    viewsets.GenericViewSet,
    mixins.ListModelMixin,
    mixins.RetrieveModelMixin,
    mixins.DestroyModelMixin,
):
    request: HttpRequest
    serializer_class = BookmarkAssetSerializer

    def get_queryset(self):
        user = self.request.user
        # limit access to assets to the owner of the bookmark for now
        bookmark = access.bookmark_write(self.request, self.kwargs["bookmark_id"])
        return BookmarkAsset.objects.filter(
            bookmark_id=bookmark.id, bookmark__owner=user
        )

    def get_serializer_context(self):
        return {"user": self.request.user}

    @action(detail=True, methods=["get"], url_path="download")
    def download(self, request: HttpRequest, bookmark_id, pk):
        asset = self.get_object()
        try:
            file_path = os.path.join(settings.LD_ASSET_FOLDER, asset.file)
            content_type = asset.content_type
            file_stream = (
                gzip.GzipFile(file_path, mode="rb")
                if asset.gzip
                else open(file_path, "rb")  # noqa: SIM115
            )
            response = StreamingHttpResponse(file_stream, content_type=content_type)
            response["Content-Disposition"] = (
                f'attachment; filename="{asset.download_name}"'
            )
            return response
        except FileNotFoundError:
            raise Http404("Asset file does not exist") from None
        except Exception as e:
            logger.error(
                f"Failed to download asset. bookmark_id={bookmark_id}, asset_id={pk}",
                exc_info=e,
            )
            return Response(status=status.HTTP_500_INTERNAL_SERVER_ERROR)

    @action(methods=["post"], detail=False)
    def upload(self, request: HttpRequest, bookmark_id):
        if settings.LD_DISABLE_ASSET_UPLOAD:
            return Response(
                {"error": "Asset upload is disabled."},
                status=status.HTTP_403_FORBIDDEN,
            )
        bookmark = access.bookmark_write(request, bookmark_id)

        upload_file = request.FILES.get("file")
        if not upload_file:
            return Response(
                {"error": "No file provided."}, status=status.HTTP_400_BAD_REQUEST
            )

        try:
            asset = assets.upload_asset(bookmark, upload_file)
            serializer = self.get_serializer(asset)
            return Response(serializer.data, status=status.HTTP_201_CREATED)
        except Exception as e:
            logger.error(
                f"Failed to upload asset file. bookmark_id={bookmark_id}, file={upload_file.name}",
                exc_info=e,
            )
            return Response(
                {"error": "Failed to upload asset."},
                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
            )

    def perform_destroy(self, instance):
        assets.remove_asset(instance)


class TagViewSet(
    viewsets.GenericViewSet,
    mixins.ListModelMixin,
    mixins.RetrieveModelMixin,
    mixins.CreateModelMixin,
):
    request: HttpRequest
    serializer_class = TagSerializer

    def get_queryset(self):
        user = self.request.user
        return Tag.objects.all().filter(owner=user)

    def get_serializer_context(self):
        return {"user": self.request.user}


class UserViewSet(viewsets.GenericViewSet):
    @action(methods=["get"], detail=False)
    def profile(self, request: HttpRequest):
        return Response(UserProfileSerializer(request.user.profile).data)


class BookmarkBundleViewSet(
    viewsets.GenericViewSet,
    mixins.ListModelMixin,
    mixins.RetrieveModelMixin,
    mixins.CreateModelMixin,
    mixins.UpdateModelMixin,
    mixins.DestroyModelMixin,
):
    request: HttpRequest
    serializer_class = BookmarkBundleSerializer

    def get_queryset(self):
        user = self.request.user
        return BookmarkBundle.objects.filter(owner=user).order_by("order")

    def get_serializer_context(self):
        return {"user": self.request.user}

    def perform_destroy(self, instance):
        bundles.delete_bundle(instance)


# DRF routers do not support nested view sets such as /bookmarks/<id>/assets/<id>/
# Instead create separate routers for each view set and manually register them in urls.py
# The default router is only used to allow reversing a URL for the API root
default_router = DefaultRouter()

bookmark_router = SimpleRouter()
bookmark_router.register("", BookmarkViewSet, basename="bookmark")

tag_router = SimpleRouter()
tag_router.register("", TagViewSet, basename="tag")

user_router = SimpleRouter()
user_router.register("", UserViewSet, basename="user")

bundle_router = SimpleRouter()
bundle_router.register("", BookmarkBundleViewSet, basename="bundle")

bookmark_asset_router = SimpleRouter()
bookmark_asset_router.register("", BookmarkAssetViewSet, basename="bookmark_asset")


================================================
FILE: bookmarks/api/serializers.py
================================================
from django.db.models import prefetch_related_objects
from django.templatetags.static import static
from rest_framework import serializers
from rest_framework.serializers import ListSerializer

from bookmarks.models import (
    Bookmark,
    BookmarkAsset,
    BookmarkBundle,
    Tag,
    UserProfile,
    build_tag_string,
)
from bookmarks.services import bookmarks, bundles
from bookmarks.services.tags import get_or_create_tag
from bookmarks.services.wayback import generate_fallback_webarchive_url
from bookmarks.utils import app_version


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 EmtpyField(serializers.ReadOnlyField):
    def to_representation(self, value):
        return None


class BookmarkBundleSerializer(serializers.ModelSerializer):
    class Meta:
        model = BookmarkBundle
        fields = [
            "id",
            "name",
            "search",
            "any_tags",
            "all_tags",
            "excluded_tags",
            "filter_unread",
            "filter_shared",
            "order",
            "date_created",
            "date_modified",
        ]
        read_only_fields = [
            "id",
            "date_created",
            "date_modified",
        ]

    def create(self, validated_data):
        bundle = BookmarkBundle(**validated_data)
        bundle.order = validated_data.get("order", None)
        return bundles.create_bundle(bundle, self.context["user"])


class BookmarkSerializer(serializers.ModelSerializer):
    class Meta:
        model = Bookmark
        fields = [
            "id",
            "url",
            "title",
            "description",
            "notes",
            "web_archive_snapshot_url",
            "favicon_url",
            "preview_image_url",
            "is_archived",
            "unread",
            "shared",
            "tag_names",
            "date_added",
            "date_modified",
            "website_title",
            "website_description",
        ]
        read_only_fields = [
            "web_archive_snapshot_url",
            "favicon_url",
            "preview_image_url",
            "tag_names",
            "website_title",
            "website_description",
        ]
        list_serializer_class = BookmarkListSerializer

    # Custom tag_names field to allow passing a list of tag names to create/update
    tag_names = TagListField(required=False)
    # Custom fields to generate URLs for favicon, preview image, and web archive snapshot
    favicon_url = serializers.SerializerMethodField()
    preview_image_url = serializers.SerializerMethodField()
    web_archive_snapshot_url = serializers.SerializerMethodField()
    # Add dummy website title and description fields for backwards compatibility but keep them empty
    website_title = EmtpyField()
    website_description = EmtpyField()
    # these are optional
    date_added = serializers.DateTimeField(required=False)
    date_modified = serializers.DateTimeField(required=False)

    def get_favicon_url(self, obj: Bookmark):
        if not obj.favicon_file:
            return None
        request = self.context.get("request")
        favicon_file_path = static(obj.favicon_file)
        favicon_url = request.build_absolute_uri(favicon_file_path)
        return favicon_url

    def get_preview_image_url(self, obj: Bookmark):
        if not obj.preview_image_file:
            return None
        request = self.context.get("request")
        preview_image_file_path = static(obj.preview_image_file)
        preview_image_url = request.build_absolute_uri(preview_image_file_path)
        return preview_image_url

    def get_web_archive_snapshot_url(self, obj: Bookmark):
        if obj.web_archive_snapshot_url:
            return obj.web_archive_snapshot_url

        return generate_fallback_webarchive_url(obj.url, obj.date_added)

    def create(self, validated_data):
        tag_names = validated_data.pop("tag_names", [])
        tag_string = build_tag_string(tag_names)
        bookmark = Bookmark(**validated_data)

        disable_scraping = self.context.get("disable_scraping", False)
        disable_html_snapshot = self.context.get("disable_html_snapshot", False)

        saved_bookmark = bookmarks.create_bookmark(
            bookmark,
            tag_string,
            self.context["user"],
            disable_html_snapshot=disable_html_snapshot,
        )
        # Unless scraping is explicitly disabled, enhance bookmark with website
        # metadata to preserve backwards compatibility with clients that expect
        # title and description to be populated automatically when left empty
        if not disable_scraping:
            bookmarks.enhance_with_website_metadata(saved_bookmark)
        return saved_bookmark

    def update(self, instance: Bookmark, validated_data):
        tag_names = validated_data.pop("tag_names", instance.tag_names)
        tag_string = build_tag_string(tag_names)

        for field_name, field in self.fields.items():
            if not field.read_only and field_name in validated_data:
                setattr(instance, field_name, validated_data[field_name])

        return bookmarks.update_bookmark(instance, tag_string, self.context["user"])

    def validate(self, attrs):
        # When creating a bookmark, the service logic prevents duplicate URLs by
        # updating the existing bookmark instead. When editing a bookmark,
        # there is no assumption that it would update a different bookmark if
        # the URL is a duplicate, so raise a validation error in that case.
        if self.instance and "url" in attrs:
            is_duplicate = (
                Bookmark.objects.filter(owner=self.instance.owner, url=attrs["url"])
                .exclude(pk=self.instance.pk)
                .exists()
            )
            if is_duplicate:
                raise serializers.ValidationError(
                    {"url": "A bookmark with this URL already exists."}
                )

        return attrs


class BookmarkAssetSerializer(serializers.ModelSerializer):
    class Meta:
        model = BookmarkAsset
        fields = [
            "id",
            "bookmark",
            "date_created",
            "file_size",
            "asset_type",
            "content_type",
            "display_name",
            "status",
        ]


class TagSerializer(serializers.ModelSerializer):
    class Meta:
        model = Tag
        fields = ["id", "name", "date_added"]
        read_only_fields = ["date_added"]

    def create(self, validated_data):
        return get_or_create_tag(validated_data["name"], self.context["user"])


class UserProfileSerializer(serializers.ModelSerializer):
    class Meta:
        model = UserProfile
        fields = [
            "theme",
            "bookmark_date_display",
            "bookmark_link_target",
            "web_archive_integration",
            "tag_search",
            "enable_sharing",
            "enable_public_sharing",
            "enable_favicons",
            "display_url",
            "permanent_notes",
            "search_preferences",
            "version",
        ]

    version = serializers.ReadOnlyField(default=app_version)


================================================
FILE: bookmarks/apps.py
================================================
from django.apps import AppConfig


class BookmarksConfig(AppConfig):
    name = "bookmarks"

    def ready(self):
        # Register signal handlers
        # noinspection PyUnusedImports
        import bookmarks.signals  # noqa: F401


================================================
FILE: bookmarks/context_processors.py
================================================
from bookmarks import utils
from bookmarks.models import Toast


def toasts(request):
    user = request.user
    toast_messages = (
        Toast.objects.filter(owner=user, acknowledged=False)
        if user.is_authenticated
        else []
    )
    has_toasts = len(toast_messages) > 0

    return {
        "has_toasts": has_toasts,
        "toast_messages": toast_messages,
    }


def app_version(request):
    return {"app_version": utils.app_version}


================================================
FILE: bookmarks/feeds.py
================================================
import unicodedata
from dataclasses import dataclass

from django.contrib.syndication.views import Feed
from django.db.models import QuerySet, prefetch_related_objects
from django.http import HttpRequest
from django.urls import reverse

from bookmarks import queries
from bookmarks.models import Bookmark, BookmarkSearch, FeedToken, UserProfile
from bookmarks.views import access


@dataclass
class FeedContext:
    request: HttpRequest
    feed_token: FeedToken | None
    query_set: QuerySet[Bookmark]


def sanitize(text: str):
    if not text:
        return ""
    # remove control characters
    valid_chars = ["\n", "\r", "\t"]
    return "".join(
        ch for ch in text if ch in valid_chars or unicodedata.category(ch)[0] != "C"
    )


class BaseBookmarksFeed(Feed):
    def get_object(self, request, feed_key: str | None):
        feed_token = FeedToken.objects.get(key__exact=feed_key) if feed_key else None
        bundle = None
        bundle_id = request.GET.get("bundle")
        if bundle_id:
            bundle = access.bundle_read(request, bundle_id)

        search = BookmarkSearch(
            q=request.GET.get("q", ""),
            unread=request.GET.get("unread", ""),
            shared=request.GET.get("shared", ""),
            bundle=bundle,
        )
        query_set = self.get_query_set(feed_token, search)
        return FeedContext(request, feed_token, query_set)

    def get_query_set(self, feed_token: FeedToken, search: BookmarkSearch):
        raise NotImplementedError

    def items(self, context: FeedContext):
        limit = context.request.GET.get("limit", 100)
        data = context.query_set[: int(limit)] if limit else list(context.query_set)
        prefetch_related_objects(data, "tags")
        return data

    def item_title(self, item: Bookmark):
        return sanitize(item.resolved_title)

    def item_description(self, item: Bookmark):
        return sanitize(item.resolved_description)

    def item_link(self, item: Bookmark):
        return item.url

    def item_pubdate(self, item: Bookmark):
        return item.date_added

    def item_categories(self, item: Bookmark):
        return item.tag_names


class AllBookmarksFeed(BaseBookmarksFeed):
    title = "All bookmarks"
    description = "All bookmarks"

    def get_query_set(self, feed_token: FeedToken, search: BookmarkSearch):
        return queries.query_bookmarks(feed_token.user, feed_token.user.profile, search)

    def link(self, context: FeedContext):
        return reverse("linkding:feeds.all", args=[context.feed_token.key])


class UnreadBookmarksFeed(BaseBookmarksFeed):
    title = "Unread bookmarks"
    description = "All unread bookmarks"

    def get_query_set(self, feed_token: FeedToken, search: BookmarkSearch):
        return queries.query_bookmarks(
            feed_token.user, feed_token.user.profile, search
        ).filter(unread=True)

    def link(self, context: FeedContext):
        return reverse("linkding:feeds.unread", args=[context.feed_token.key])


class SharedBookmarksFeed(BaseBookmarksFeed):
    title = "Shared bookmarks"
    description = "All shared bookmarks"

    def get_query_set(self, feed_token: FeedToken, search: BookmarkSearch):
        return queries.query_shared_bookmarks(
            None, feed_token.user.profile, search, False
        )

    def link(self, context: FeedContext):
        return reverse("linkding:feeds.shared", args=[context.feed_token.key])


class PublicSharedBookmarksFeed(BaseBookmarksFeed):
    title = "Public shared bookmarks"
    description = "All public shared bookmarks"

    def get_object(self, request):
        return super().get_object(request, None)

    def get_query_set(self, feed_token: FeedToken, search: BookmarkSearch):
        return queries.query_shared_bookmarks(None, UserProfile(), search, True)

    def link(self, context: FeedContext):
        return reverse("linkding:feeds.public_shared")


================================================
FILE: bookmarks/forms.py
================================================
from django import forms
from django.contrib.auth.models import User
from django.db import models
from django.utils import timezone

from bookmarks.models import (
    Bookmark,
    BookmarkBundle,
    BookmarkSearch,
    GlobalSettings,
    Tag,
    UserProfile,
    build_tag_string,
    parse_tag_string,
    sanitize_tag_name,
)
from bookmarks.services.bookmarks import create_bookmark, update_bookmark
from bookmarks.type_defs import HttpRequest
from bookmarks.validators import BookmarkURLValidator
from bookmarks.widgets import (
    FormCheckbox,
    FormErrorList,
    FormInput,
    FormNumberInput,
    FormSelect,
    FormTextarea,
    TagAutocomplete,
)


class BookmarkForm(forms.ModelForm):
    # Use URLField for URL
    url = forms.CharField(validators=[BookmarkURLValidator()], widget=FormInput)
    tag_string = forms.CharField(required=False, widget=TagAutocomplete)
    # Do not require title and description as they may be empty
    title = forms.CharField(max_length=512, required=False, widget=FormInput)
    description = forms.CharField(required=False, widget=FormTextarea)
    notes = forms.CharField(required=False, widget=FormTextarea)
    unread = forms.BooleanField(required=False, widget=FormCheckbox)
    shared = forms.BooleanField(required=False, widget=FormCheckbox)
    # Hidden field that determines whether to close window/tab after saving the bookmark
    auto_close = forms.CharField(required=False, widget=forms.HiddenInput)

    class Meta:
        model = Bookmark
        fields = [
            "url",
            "tag_string",
            "title",
            "description",
            "notes",
            "unread",
            "shared",
            "auto_close",
        ]

    def __init__(self, request: HttpRequest, instance: Bookmark = None):
        self.request = request

        initial = None
        if instance is None and request.method == "GET":
            initial = {
                "url": request.GET.get("url"),
                "title": request.GET.get("title"),
                "description": request.GET.get("description"),
                "notes": request.GET.get("notes"),
                "tag_string": request.GET.get("tags"),
                "auto_close": "auto_close" in request.GET,
                "unread": request.user_profile.default_mark_unread,
                "shared": request.user_profile.default_mark_shared,
            }
        if instance is not None and request.method == "GET":
            initial = {"tag_string": build_tag_string(instance.tag_names, " ")}
        data = request.POST if request.method == "POST" else None
        super().__init__(
            data, instance=instance, initial=initial, error_class=FormErrorList
        )

    @property
    def is_auto_close(self):
        return self.data.get("auto_close", False) == "True" or self.initial.get(
            "auto_close", False
        )

    @property
    def has_notes(self):
        return self.initial.get("notes", None) or (
            self.instance and self.instance.notes
        )

    def save(self, commit=False):
        tag_string = convert_tag_string(self.data["tag_string"])
        bookmark = super().save(commit=False)
        if self.instance.pk:
            return update_bookmark(bookmark, tag_string, self.request.user)
        else:
            return create_bookmark(bookmark, tag_string, self.request.user)

    def clean_url(self):
        # When creating a bookmark, the service logic prevents duplicate URLs by
        # updating the existing bookmark instead, which is also communicated in
        # the form's UI. When editing a bookmark, there is no assumption that
        # it would update a different bookmark if the URL is a duplicate, so
        # raise a validation error in that case.
        url = self.cleaned_data["url"]
        if self.instance.pk:
            is_duplicate = (
                Bookmark.query_existing(self.instance.owner, url)
                .exclude(pk=self.instance.pk)
                .exists()
            )
            if is_duplicate:
                raise forms.ValidationError("A bookmark with this URL already exists.")

        return url


def convert_tag_string(tag_string: str):
    # Tag strings coming from inputs are space-separated, however services.bookmarks functions expect comma-separated
    # strings
    return tag_string.replace(" ", ",")


class TagForm(forms.ModelForm):
    name = forms.CharField(widget=FormInput)

    class Meta:
        model = Tag
        fields = ["name"]

    def __init__(self, user, *args, **kwargs):
        super().__init__(*args, **kwargs, error_class=FormErrorList)
        self.user = user

    def clean_name(self):
        name = self.cleaned_data.get("name", "").strip()

        name = sanitize_tag_name(name)

        queryset = Tag.objects.filter(name__iexact=name, owner=self.user)
        if self.instance.pk:
            queryset = queryset.exclude(pk=self.instance.pk)

        if queryset.exists():
            raise forms.ValidationError(f'Tag "{name}" already exists.')

        return name

    def save(self, commit=True):
        tag = super().save(commit=False)
        if not self.instance.pk:
            tag.owner = self.user
            tag.date_added = timezone.now()
        else:
            tag.date_modified = timezone.now()
        if commit:
            tag.save()
        return tag


class TagMergeForm(forms.Form):
    target_tag = forms.CharField(widget=TagAutocomplete)
    merge_tags = forms.CharField(widget=TagAutocomplete)

    def __init__(self, user, *args, **kwargs):
        super().__init__(*args, **kwargs, error_class=FormErrorList)
        self.user = user

    def clean_target_tag(self):
        target_tag_name = self.cleaned_data.get("target_tag", "")

        target_tag_names = parse_tag_string(target_tag_name, " ")
        if len(target_tag_names) != 1:
            raise forms.ValidationError(
                "Please enter only one tag name for the target tag."
            )

        target_tag_name = target_tag_names[0]

        try:
            target_tag = Tag.objects.get(name__iexact=target_tag_name, owner=self.user)
        except Tag.DoesNotExist:
            raise forms.ValidationError(
                f'Tag "{target_tag_name}" does not exist.'
            ) from None

        return target_tag

    def clean_merge_tags(self):
        merge_tags_string = self.cleaned_data.get("merge_tags", "")

        merge_tag_names = parse_tag_string(merge_tags_string, " ")
        if not merge_tag_names:
            raise forms.ValidationError("Please enter at least one tag to merge.")

        merge_tags = []
        for tag_name in merge_tag_names:
            try:
                tag = Tag.objects.get(name__iexact=tag_name, owner=self.user)
                merge_tags.append(tag)
            except Tag.DoesNotExist:
                raise forms.ValidationError(
                    f'Tag "{tag_name}" does not exist.'
                ) from None

        target_tag = self.cleaned_data.get("target_tag")
        if target_tag and target_tag in merge_tags:
            raise forms.ValidationError(
                "The target tag cannot be selected for merging."
            )

        return merge_tags


class BookmarkBundleForm(forms.ModelForm):
    name = forms.CharField(max_length=256, widget=FormInput)
    search = forms.CharField(max_length=256, required=False, widget=FormInput)
    any_tags = forms.CharField(required=False, widget=TagAutocomplete)
    all_tags = forms.CharField(required=False, widget=TagAutocomplete)
    excluded_tags = forms.CharField(required=False, widget=TagAutocomplete)
    filter_unread = forms.ChoiceField(
        choices=BookmarkBundle.FILTER_UNREAD_CHOICES,
        required=False,
        widget=FormSelect,
    )
    filter_shared = forms.ChoiceField(
        choices=BookmarkBundle.FILTER_SHARED_CHOICES,
        required=False,
        widget=FormSelect,
    )

    class Meta:
        model = BookmarkBundle
        fields = [
            "name",
            "search",
            "any_tags",
            "all_tags",
            "excluded_tags",
            "filter_unread",
            "filter_shared",
        ]

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs, error_class=FormErrorList)


class BookmarkSearchForm(forms.Form):
    SORT_CHOICES = [
        (BookmarkSearch.SORT_ADDED_ASC, "Added ↑"),
        (BookmarkSearch.SORT_ADDED_DESC, "Added ↓"),
        (BookmarkSearch.SORT_TITLE_ASC, "Title ↑"),
        (BookmarkSearch.SORT_TITLE_DESC, "Title ↓"),
    ]
    FILTER_SHARED_CHOICES = [
        (BookmarkSearch.FILTER_SHARED_OFF, "Off"),
        (BookmarkSearch.FILTER_SHARED_SHARED, "Shared"),
        (BookmarkSearch.FILTER_SHARED_UNSHARED, "Unshared"),
    ]
    FILTER_UNREAD_CHOICES = [
        (BookmarkSearch.FILTER_UNREAD_OFF, "Off"),
        (BookmarkSearch.FILTER_UNREAD_YES, "Unread"),
        (BookmarkSearch.FILTER_UNREAD_NO, "Read"),
    ]

    q = forms.CharField()
    user = forms.ChoiceField(required=False, widget=FormSelect)
    bundle = forms.CharField(required=False)
    sort = forms.ChoiceField(choices=SORT_CHOICES, widget=FormSelect)
    shared = forms.ChoiceField(choices=FILTER_SHARED_CHOICES, widget=forms.RadioSelect)
    unread = forms.ChoiceField(choices=FILTER_UNREAD_CHOICES, widget=forms.RadioSelect)
    modified_since = forms.CharField(required=False)
    added_since = forms.CharField(required=False)

    def __init__(
        self,
        search: BookmarkSearch,
        editable_fields: list[str] = None,
        users: list[User] = None,
    ):
        super().__init__()
        editable_fields = editable_fields or []
        self.editable_fields = editable_fields

        # set choices for user field if users are provided
        if users:
            user_choices = [(user.username, user.username) for user in users]
            user_choices.insert(0, ("", "Everyone"))
            self.fields["user"].choices = user_choices

        for param in search.params:
            # set initial values for modified params
            value = search.__dict__.get(param)
            if isinstance(value, models.Model):
                self.fields[param].initial = value.id
            else:
                self.fields[param].initial = value

            # Mark non-editable modified fields as hidden. That way, templates
            # rendering a form can just loop over hidden_fields to ensure that
            # all necessary search options are kept when submitting the form.
            if search.is_modified(param) and param not in editable_fields:
                self.fields[param].widget = forms.HiddenInput()


class UserProfileForm(forms.ModelForm):
    class Meta:
        model = UserProfile
        fields = [
            "theme",
            "bookmark_date_display",
            "bookmark_description_display",
            "bookmark_description_max_lines",
            "bookmark_link_target",
            "web_archive_integration",
            "tag_search",
            "tag_grouping",
            "enable_sharing",
            "enable_public_sharing",
            "enable_favicons",
            "enable_preview_images",
            "enable_automatic_html_snapshots",
            "display_url",
            "display_view_bookmark_action",
            "display_edit_bookmark_action",
            "display_archive_bookmark_action",
            "display_remove_bookmark_action",
            "permanent_notes",
            "default_mark_unread",
            "default_mark_shared",
            "custom_css",
            "auto_tagging_rules",
            "items_per_page",
            "sticky_pagination",
            "collapse_side_panel",
            "hide_bundles",
            "legacy_search",
        ]
        widgets = {
            "theme": FormSelect,
            "bookmark_date_display": FormSelect,
            "bookmark_description_display": FormSelect,
            "bookmark_description_max_lines": FormNumberInput,
            "bookmark_link_target": FormSelect,
            "web_archive_integration": FormSelect,
            "tag_search": FormSelect,
            "tag_grouping": FormSelect,
            "auto_tagging_rules": FormTextarea,
            "custom_css": FormTextarea,
            "items_per_page": FormNumberInput,
            "display_url": FormCheckbox,
            "permanent_notes": FormCheckbox,
            "display_view_bookmark_action": FormCheckbox,
            "display_edit_bookmark_action": FormCheckbox,
            "display_archive_bookmark_action": FormCheckbox,
            "display_remove_bookmark_action": FormCheckbox,
            "sticky_pagination": FormCheckbox,
            "collapse_side_panel": FormCheckbox,
            "hide_bundles": FormCheckbox,
            "legacy_search": FormCheckbox,
            "enable_favicons": FormCheckbox,
            "enable_preview_images": FormCheckbox,
            "enable_sharing": FormCheckbox,
            "enable_public_sharing": FormCheckbox,
            "enable_automatic_html_snapshots": FormCheckbox,
            "default_mark_unread": FormCheckbox,
            "default_mark_shared": FormCheckbox,
        }


class GlobalSettingsForm(forms.ModelForm):
    class Meta:
        model = GlobalSettings
        fields = ["landing_page", "guest_profile_user", "enable_link_prefetch"]
        widgets = {
            "landing_page": FormSelect,
            "guest_profile_user": FormSelect,
            "enable_link_prefetch": FormCheckbox,
        }

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.fields["guest_profile_user"].empty_label = "Standard profile"


================================================
FILE: bookmarks/frontend/api.js
================================================
export class Api {
  constructor(baseUrl) {
    this.baseUrl = baseUrl;
  }

  listBookmarks(search, options = { limit: 100, offset: 0, path: "" }) {
    const query = [`limit=${options.limit}`, `offset=${options.offset}`];
    Object.keys(search).forEach((key) => {
      const value = search[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())
      .then((data) => data.results);
  }

  getTags(options = { limit: 100, offset: 0 }) {
    const url = `${this.baseUrl}tags/?limit=${options.limit}&offset=${options.offset}`;

    return fetch(url)
      .then((response) => response.json())
      .then((data) => data.results);
  }
}

const apiBaseUrl = document.documentElement.dataset.apiBaseUrl || "";
export const api = new Api(apiBaseUrl);


================================================
FILE: bookmarks/frontend/components/bookmark-page.js
================================================
import { HeadlessElement } from "../utils/element.js";

class BookmarkPage extends HeadlessElement {
  init() {
    this.update = this.update.bind(this);
    this.onToggleNotes = this.onToggleNotes.bind(this);
    this.onToggleBulkEdit = this.onToggleBulkEdit.bind(this);
    this.onBulkActionChange = this.onBulkActionChange.bind(this);
    this.onToggleAll = this.onToggleAll.bind(this);
    this.onToggleBookmark = this.onToggleBookmark.bind(this);

    this.oldItems = [];
    this.update();
    document.addEventListener("bookmark-list-updated", this.update);
  }

  disconnectedCallback() {
    document.removeEventListener("bookmark-list-updated", this.update);
  }

  update() {
    const items = this.querySelectorAll("ul.bookmark-list > li");
    this.updateTooltips(items);
    this.updateNotesToggles(items, this.oldItems);
    this.updateBulkEdit(items, this.oldItems);
    this.oldItems = items;
  }

  updateTooltips(items) {
    // Add tooltip to title if it is truncated
    items.forEach((item) => {
      const titleAnchor = item.querySelector(".title > a");
      const titleSpan = titleAnchor.querySelector("span");
      if (titleSpan.offsetWidth > titleAnchor.offsetWidth) {
        titleAnchor.dataset.tooltip = titleSpan.textContent;
      } else {
        delete titleAnchor.dataset.tooltip;
      }
    });
  }

  updateNotesToggles(items, oldItems) {
    oldItems.forEach((oldItem) => {
      const oldToggle = oldItem.querySelector(".toggle-notes");
      if (oldToggle) {
        oldToggle.removeEventListener("click", this.onToggleNotes);
      }
    });

    items.forEach((item) => {
      const notesToggle = item.querySelector(".toggle-notes");
      if (notesToggle) {
        notesToggle.addEventListener("click", this.onToggleNotes);
      }
    });
  }

  onToggleNotes(event) {
    event.preventDefault();
    event.stopPropagation();
    event.target.closest("li").classList.toggle("show-notes");
  }

  updateBulkEdit() {
    if (this.hasAttribute("no-bulk-edit")) {
      return;
    }

    // Remove existing listeners
    this.activeToggle?.removeEventListener("click", this.onToggleBulkEdit);
    this.actionSelect?.removeEventListener("change", this.onBulkActionChange);
    this.allCheckbox?.removeEventListener("change", this.onToggleAll);
    this.bookmarkCheckboxes?.forEach((checkbox) => {
      checkbox.removeEventListener("change", this.onToggleBookmark);
    });

    // Re-query elements
    this.activeToggle = this.querySelector(".bulk-edit-active-toggle");
    this.actionSelect = this.querySelector("select[name='bulk_action']");
    this.allCheckbox = this.querySelector(".bulk-edit-checkbox.all input");
    this.bookmarkCheckboxes = Array.from(
      this.querySelectorAll(".bulk-edit-checkbox:not(.all) input"),
    );
    this.selectAcross = this.querySelector("label.select-across");
    this.executeButton = this.querySelector("button[name='bulk_execute']");

    // Add listeners
    this.activeToggle.addEventListener("click", this.onToggleBulkEdit);
    this.actionSelect.addEventListener("change", this.onBulkActionChange);
    this.allCheckbox.addEventListener("change", this.onToggleAll);
    this.bookmarkCheckboxes.forEach((checkbox) => {
      checkbox.addEventListener("change", this.onToggleBookmark);
    });

    // Reset checkbox states
    this.allCheckbox.checked = false;
    this.bookmarkCheckboxes.forEach((checkbox) => {
      checkbox.checked = false;
    });
    this.updateSelectAcross(false);
    this.updateExecuteButton();

    // Update total number of bookmarks
    const totalHolder = this.querySelector("[data-bookmarks-total]");
    const total = totalHolder?.dataset.bookmarksTotal || 0;
    const totalSpan = this.selectAcross.querySelector("span.total");
    totalSpan.textContent = total;
  }

  onToggleBulkEdit() {
    this.classList.toggle("active");
  }

  onBulkActionChange() {
    this.dataset.bulkAction = this.actionSelect.value;
  }

  onToggleAll() {
    const allChecked = this.allCheckbox.checked;
    this.bookmarkCheckboxes.forEach((checkbox) => {
      checkbox.checked = allChecked;
    });
    this.updateSelectAcross(allChecked);
    this.updateExecuteButton();
  }

  onToggleBookmark() {
    const allChecked = this.bookmarkCheckboxes.every((checkbox) => {
      return checkbox.checked;
    });
    this.allCheckbox.checked = allChecked;
    this.updateSelectAcross(allChecked);
    this.updateExecuteButton();
  }

  updateSelectAcross(allChecked) {
    if (allChecked) {
      this.selectAcross.classList.remove("d-none");
    } else {
      this.selectAcross.classList.add("d-none");
      this.selectAcross.querySelector("input").checked = false;
    }
  }

  updateExecuteButton() {
    const anyChecked = this.bookmarkCheckboxes.some((checkbox) => {
      return checkbox.checked;
    });
    this.executeButton.disabled = !anyChecked;
  }
}

customElements.define("ld-bookmark-page", BookmarkPage);


================================================
FILE: bookmarks/frontend/components/clear-button.js
================================================
import { HeadlessElement } from "../utils/element";

class ClearButton extends HeadlessElement {
  init() {
    this.field = document.getElementById(this.dataset.for);
    if (!this.field) {
      console.error(`Field with ID ${this.dataset.for} not found`);
      return;
    }
    this.update = this.update.bind(this);
    this.clear = this.clear.bind(this);

    this.addEventListener("click", this.clear);
    this.field.addEventListener("input", this.update);
    this.field.addEventListener("value-changed", this.update);
    this.update();
  }

  update() {
    this.style.display = this.field.value ? "inline" : "none";
  }

  clear() {
    this.field.value = "";
    this.field.focus();
    this.update();
  }
}

customElements.define("ld-clear-button", ClearButton);


================================================
FILE: bookmarks/frontend/components/confirm-dropdown.js
================================================
import { html, LitElement } from "lit";
import { FocusTrapController, isKeyboardActive } from "../utils/focus.js";
import { PositionController } from "../utils/position-controller.js";

let confirmId = 0;

function nextConfirmId() {
  return `confirm-${confirmId++}`;
}

function removeAll() {
  document
    .querySelectorAll("ld-confirm-dropdown")
    .forEach((dropdown) => dropdown.close());
}

// Create a confirm dropdown whenever a button with the data-confirm attribute is clicked
document.addEventListener("click", (event) => {
  // Check if the clicked element is a button with data-confirm
  const button = event.target.closest("button[data-confirm]");
  if (!button) return;

  // Remove any existing confirm dropdowns
  removeAll();

  // Show confirmation dropdown
  event.preventDefault();

  const dropdown = document.createElement("ld-confirm-dropdown");
  dropdown.button = button;
  document.body.appendChild(dropdown);
});

// Remove all confirm dropdowns when:
// - Turbo caches the page
// - The escape key is pressed
document.addEventListener("turbo:before-cache", removeAll);
document.addEventListener("keydown", (event) => {
  if (event.key === "Escape") {
    removeAll();
  }
});

class ConfirmDropdown extends LitElement {
  constructor() {
    super();
    this.confirmId = nextConfirmId();
  }

  createRenderRoot() {
    return this;
  }

  firstUpdated(props) {
    super.firstUpdated(props);
    this.classList.add("dropdown", "confirm-dropdown", "active");

    const menu = this.querySelector(".menu");
    this.positionController = new PositionController({
      anchor: this.button,
      overlay: menu,
      arrow: this.querySelector(".menu-arrow"),
      offset: 12,
    });
    this.positionController.enable();
    this.focusTrap = new FocusTrapController(menu);
  }

  render() {
    const questionText = this.button.dataset.confirmQuestion || "Are you sure?";
    return html`
      <div
        class="menu with-arrow"
        role="alertdialog"
        aria-modal="true"
        aria-labelledby=${this.confirmId}
      >
        <span id=${this.confirmId} style="font-weight: bold;">
          ${questionText}
        </span>
        <button type="button" class="btn" @click=${this.close}>Cancel</button>
        <button type="submit" class="btn btn-error" @click=${this.confirm}>
          Confirm
        </button>
        <div class="menu-arrow"></div>
      </div>
    `;
  }

  confirm() {
    this.button.closest("form").requestSubmit(this.button);
    this.close();
  }

  close() {
    this.positionController.disable();
    this.focusTrap.destroy();
    this.remove();
    this.button.focus({ focusVisible: isKeyboardActive() });
  }
}

customElements.define("ld-confirm-dropdown", ConfirmDropdown);


================================================
FILE: bookmarks/frontend/components/details-modal.js
================================================
import { setAfterPageLoadFocusTarget } from "../utils/focus.js";
import { Modal } from "./modal.js";

class DetailsModal extends Modal {
  doClose() {
    super.doClose();

    // Try restore focus to view details to view details link of respective bookmark
    const bookmarkId = this.dataset.bookmarkId;
    setAfterPageLoadFocusTarget(
      `ul.bookmark-list li[data-bookmark-id='${bookmarkId}'] a.view-action`,
    );
  }
}

customElements.define("ld-details-modal", DetailsModal);


================================================
FILE: bookmarks/frontend/components/dev-tool.js
================================================
import { LitElement, html, css } from "lit";

class DevTool extends LitElement {
  static properties = {
    profile: { type: Object, state: true },
    formAction: { type: String, attribute: "data-form-action" },
    csrfToken: { type: String, attribute: "data-csrf-token" },
    isOpen: { type: Boolean, state: true },
  };

  static styles = css`
    :host {
      position: fixed;
      bottom: 1rem;
      right: 1rem;
      z-index: 10000;
    }

    .button {
      background: var(--btn-primary-bg-color);
      color: var(--btn-primary-text-color);
      border: none;
      padding: var(--unit-2);
      border-radius: var(--border-radius);
      box-shadow: var(--btn-box-shadow);
      cursor: pointer;
      height: auto;
      line-height: 0;
    }

    .overlay {
      display: none;
      position: absolute;
      bottom: 100%;
      right: 0;
      background: var(--body-color);
      color: var(--text-color);
      border: 1px solid var(--border-color);
      border-radius: var(--border-radius);
      padding: var(--unit-2);
      margin-bottom: var(--unit-2);
      min-width: 220px;
      box-shadow: var(--box-shadow-lg);
      font-size: var(--font-size-sm);
    }

    :host([open]) .overlay {
      display: block;
    }

    h3 {
      margin: 0 0 var(--unit-2) 0;
    }

    label {
      display: flex;
      align-items: center;
      gap: var(--unit-1);
      cursor: pointer;
    }

    label:has(select) {
      margin-bottom: var(--unit-1);
    }

    label:has(select) span {
      min-width: 100px;
    }

    hr {
      margin: var(--unit-2) 0;
      border: none;
      border-top: 1px solid var(--border-color);
    }
  `;

  static fields = [
    {
      type: "select",
      key: "theme",
      label: "Theme",
      options: [
        { value: "auto", label: "Auto" },
        { value: "light", label: "Light" },
        { value: "dark", label: "Dark" },
      ],
    },
    {
      type: "select",
      key: "bookmark_date_display",
      label: "Date",
      options: [
        { value: "relative", label: "Relative" },
        { value: "absolute", label: "Absolute" },
        { value: "hidden", label: "Hidden" },
      ],
    },
    {
      type: "select",
      key: "bookmark_description_display",
      label: "Description",
      options: [
        { value: "inline", label: "Inline" },
        { value: "separate", label: "Separate" },
      ],
    },
    { type: "checkbox", key: "enable_favicons", label: "Favicons" },
    { type: "checkbox", key: "enable_preview_images", label: "Preview images" },
    { type: "checkbox", key: "display_url", label: "Display URL" },
    { type: "checkbox", key: "permanent_notes", label: "Permanent notes" },
    { type: "checkbox", key: "collapse_side_panel", label: "Collapse sidebar" },
    { type: "checkbox", key: "sticky_pagination", label: "Sticky pagination" },
    { type: "checkbox", key: "hide_bundles", label: "Hide bundles" },
  ];

  constructor() {
    super();
    this.isOpen = false;
    this.profile = {};
    this._onOutsideClick = this._onOutsideClick.bind(this);
  }

  connectedCallback() {
    super.connectedCallback();
    const profileData = document.getElementById("json_profile");
    this.profile = JSON.parse(profileData.textContent || "{}");
    document.addEventListener("click", this._onOutsideClick);
  }

  disconnectedCallback() {
    super.disconnectedCallback();
    document.removeEventListener("click", this._onOutsideClick);
  }

  _onOutsideClick(e) {
    if (!this.contains(e.target) && this.isOpen) {
      this.isOpen = false;
      this.removeAttribute("open");
    }
  }

  _toggle() {
    this.isOpen = !this.isOpen;
    if (this.isOpen) {
      this.setAttribute("open", "");
    } else {
      this.removeAttribute("open");
    }
  }

  _handleChange(key, value) {
    this.profile = { ...this.profile, [key]: value };
    if (key === "theme") {
      const themeLinks = document.head.querySelectorAll('link[href*="theme"]');
      themeLinks.forEach((link) => link.remove());
    }
    this._submitForm();
  }

  _renderField(field) {
    switch (field.type) {
      case "checkbox":
        return html`
          <label>
            <input
              type="checkbox"
              .checked=${this.profile[field.key] || false}
              @change=${(e) => this._handleChange(field.key, e.target.checked)}
            />
            ${field.label}
          </label>
        `;
      case "select":
        return html`
          <label>
            <span>${field.label}:</span>
            <select
              @change=${(e) => this._handleChange(field.key, e.target.value)}
            >
              ${field.options.map(
                (opt) => html`
                  <option
                    value=${opt.value}
                    ?selected=${this.profile[field.key] === opt.value}
                  >
                    ${opt.label}
                  </option>
                `,
              )}
            </select>
          </label>
        `;
      case "divider":
        return html`<hr />`;
      default:
        return null;
    }
  }

  async _submitForm() {
    const formData = new FormData();
    formData.append("csrfmiddlewaretoken", this.csrfToken);

    // Profile fields
    for (const [key, value] of Object.entries(this.profile)) {
      if (typeof value === "boolean" && value) {
        formData.append(key, "on");
      } else if (typeof value !== "boolean") {
        formData.append(key, value);
      }
    }

    // Submit button name that settings.update expects
    formData.append("update_profile", "1");

    await fetch(this.formAction, {
      method: "POST",
      body: formData,
    });

    const url = new URL(window.location);
    url.searchParams.set("ts", Date.now().toString());
    window.history.replaceState({}, "", url);

    Turbo.visit(url.toString());
  }

  render() {
    return html`
      <button class="button" @click=${() => this._toggle()}>
        <svg
          xmlns="http://www.w3.org/2000/svg"
          width="24"
          height="24"
          viewBox="0 0 24 24"
          fill="none"
          stroke="currentColor"
          stroke-width="2"
          stroke-linecap="round"
          stroke-linejoin="round"
        >
          <path stroke="none" d="M0 0h24v24H0z" fill="none" />
          <path
            d="M10.325 4.317c.426 -1.756 2.924 -1.756 3.35 0a1.724 1.724 0 0 0 2.573 1.066c1.543 -.94 3.31 .826 2.37 2.37a1.724 1.724 0 0 0 1.065 2.572c1.756 .426 1.756 2.924 0 3.35a1.724 1.724 0 0 0 -1.066 2.573c.94 1.543 -.826 3.31 -2.37 2.37a1.724 1.724 0 0 0 -2.572 1.065c-.426 1.756 -2.924 1.756 -3.35 0a1.724 1.724 0 0 0 -2.573 -1.066c-1.543 .94 -3.31 -.826 -2.37 -2.37a1.724 1.724 0 0 0 -1.065 -2.572c-1.756 -.426 -1.756 -2.924 0 -3.35a1.724 1.724 0 0 0 1.066 -2.573c-.94 -1.543 .826 -3.31 2.37 -2.37c1 .608 2.296 .07 2.572 -1.065"
          />
          <path d="M9 12a3 3 0 1 0 6 0a3 3 0 0 0 -6 0" />
        </svg>
      </button>
      <div class="overlay">
        <h3>Dev Tools</h3>
        ${DevTool.fields.map((field) => this._renderField(field))}
      </div>
    `;
  }
}

customElements.define("ld-dev-tool", DevTool);


================================================
FILE: bookmarks/frontend/components/dropdown.js
================================================
import { HeadlessElement } from "../utils/element.js";

class Dropdown extends HeadlessElement {
  constructor() {
    super();
    this.opened = false;
    this.onClick = this.onClick.bind(this);
    this.onOutsideClick = this.onOutsideClick.bind(this);
    this.onEscape = this.onEscape.bind(this);
    this.onFocusOut = this.onFocusOut.bind(this);
  }

  init() {
    // Prevent opening the dropdown automatically on focus, so that it only
    // opens on click when JS is enabled
    this.style.setProperty("--dropdown-focus-display", "none");
    this.addEventListener("keydown", this.onEscape);
    this.addEventListener("focusout", this.onFocusOut);

    this.toggle = this.querySelector(".dropdown-toggle");
    this.toggle.setAttribute("aria-expanded", "false");
    this.toggle.addEventListener("click", this.onClick);
  }

  disconnectedCallback() {
    this.close();
  }

  open() {
    this.opened = true;
    this.classList.add("active");
    this.toggle.setAttribute("aria-expanded", "true");
    document.addEventListener("click", this.onOutsideClick);
  }

  close() {
    this.opened = false;
    this.classList.remove("active");
    this.toggle?.setAttribute("aria-expanded", "false");
    document.removeEventListener("click", this.onOutsideClick);
  }

  onClick() {
    if (this.opened) {
      this.close();
    } else {
      this.open();
    }
  }

  onOutsideClick(event) {
    if (!this.contains(event.target)) {
      this.close();
    }
  }

  onEscape(event) {
    if (event.key === "Escape" && this.opened) {
      event.preventDefault();
      this.close();
      this.toggle.focus();
    }
  }

  onFocusOut(event) {
    if (!this.contains(event.relatedTarget)) {
      this.close();
    }
  }
}

customElements.define("ld-dropdown", Dropdown);


================================================
FILE: bookmarks/frontend/components/filter-drawer.js
================================================
import { html, render } from "lit";
import { Modal } from "./modal.js";
import { HeadlessElement } from "../utils/element.js";
import { isKeyboardActive } from "../utils/focus.js";

class FilterDrawerTrigger extends HeadlessElement {
  init() {
    this.onClick = this.onClick.bind(this);
    this.addEventListener("click", this.onClick.bind(this));
  }

  onClick() {
    const modal = document.createElement("ld-filter-drawer");
    document.body.querySelector(".modals").appendChild(modal);
  }
}

customElements.define("ld-filter-drawer-trigger", FilterDrawerTrigger);

class FilterDrawer extends Modal {
  connectedCallback() {
    this.classList.add("modal", "drawer");

    // Render modal structure
    render(
      html`
        <div class="modal-overlay" data-close-modal></div>
        <div class="modal-container" role="dialog" aria-modal="true">
          <div class="modal-header">
            <h2>Filters</h2>
            <button
              class="btn btn-noborder close"
              aria-label="Close dialog"
              data-close-modal
            >
              <svg
                xmlns="http://www.w3.org/2000/svg"
                width="24"
                height="24"
                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="M18 6l-12 12"></path>
                <path d="M6 6l12 12"></path>
              </svg>
            </button>
          </div>
          <div class="modal-body"></div>
        </div>
      `,
      this,
    );
    // Teleport filter content
    this.teleport();
    // Force close on turbo cache to restore content
    this.doClose = this.doClose.bind(this);
    document.addEventListener("turbo:before-cache", this.doClose);
    // Force reflow to make transform transition work
    this.getBoundingClientRect();
    // Add active class to start slide-in animation
    requestAnimationFrame(() => this.classList.add("active"));
    // Call super.init() after rendering to ensure elements are available
    super.init();
  }

  disconnectedCallback() {
    super.disconnectedCallback();
    this.teleportBack();
    document.removeEventListener("turbo:before-cache", this.doClose);
  }

  mapHeading(container, from, to) {
    const headings = container.querySelectorAll(from);
    headings.forEach((heading) => {
      const newHeading = document.createElement(to);
      newHeading.textContent = heading.textContent;
      heading.replaceWith(newHeading);
    });
  }

  teleport() {
    const content = this.querySelector(".modal-body");
    const sidePanel = document.querySelector(".side-panel");
    content.append(...sidePanel.children);
    this.mapHeading(content, "h2", "h3");
  }

  teleportBack() {
    const sidePanel = document.querySelector(".side-panel");
    const content = this.querySelector(".modal-body");
    sidePanel.append(...content.children);
    this.mapHeading(sidePanel, "h3", "h2");
  }

  doClose() {
    super.doClose();

    // Try restore focus to drawer trigger
    const restoreFocusElement =
      document.querySelector("ld-filter-drawer-trigger") || document.body;
    restoreFocusElement.focus({ focusVisible: isKeyboardActive() });
  }
}

customElements.define("ld-filter-drawer", FilterDrawer);


================================================
FILE: bookmarks/frontend/components/form.js
================================================
import { HeadlessElement } from "../utils/element.js";

class Form extends HeadlessElement {
  constructor() {
    super();
    this.onKeyDown = this.onKeyDown.bind(this);
    this.onChange = this.onChange.bind(this);
  }

  init() {
    this.addEventListener("keydown", this.onKeyDown);
    this.addEventListener("change", this.onChange);

    if (this.hasAttribute("data-form-reset")) {
      // Resets form controls to their initial values before Turbo caches the DOM.
      // Useful for filter forms where navigating back would otherwise still show
      // values from after the form submission, which means the filters would be out
      // of sync with the URL.
      this.initFormReset();
    }
  }

  disconnectedCallback() {
    if (this.hasAttribute("data-form-reset")) {
      this.resetForm();
    }
  }

  onChange(event) {
    if (event.target.hasAttribute("data-submit-on-change")) {
      this.querySelector("form")?.requestSubmit();
    }
  }

  onKeyDown(event) {
    // Check for Ctrl/Cmd + Enter combination
    if (
      this.hasAttribute("data-submit-on-ctrl-enter") &&
      event.key === "Enter" &&
      (event.metaKey || event.ctrlKey)
    ) {
      event.preventDefault();
      event.stopPropagation();
      this.querySelector("form")?.requestSubmit();
    }
  }

  initFormReset() {
    this.controls = this.querySelectorAll("input, select");
    this.controls.forEach((control) => {
      if (control.type === "checkbox" || control.type === "radio") {
        control.__initialValue = control.checked;
      } else {
        control.__initialValue = control.value;
      }
    });
  }

  resetForm() {
    this.controls.forEach((control) => {
      if (control.type === "checkbox" || control.type === "radio") {
        control.checked = control.__initialValue;
      } else {
        control.value = control.__initialValue;
      }
      delete control.__initialValue;
    });
  }
}

customElements.define("ld-form", Form);


================================================
FILE: bookmarks/frontend/components/modal.js
================================================
import { FocusTrapController } from "../utils/focus.js";
import { HeadlessElement } from "../utils/element.js";

export class Modal extends HeadlessElement {
  init() {
    this.onClose = this.onClose.bind(this);
    this.onKeyDown = this.onKeyDown.bind(this);

    this.querySelectorAll("[data-close-modal]").forEach((btn) => {
      btn.addEventListener("click", this.onClose);
    });
    this.addEventListener("keydown", this.onKeyDown);

    this.setupScrollLock();
    this.focusTrap = new FocusTrapController(
      this.querySelector(".modal-container"),
    );
  }

  disconnectedCallback() {
    this.removeScrollLock();
    this.focusTrap.destroy();
  }

  setupScrollLock() {
    document.body.classList.add("scroll-lock");
  }

  removeScrollLock() {
    document.body.classList.remove("scroll-lock");
  }

  onKeyDown(event) {
    // Skip if event occurred within an input element
    const targetNodeName = event.target.nodeName;
    const isInputTarget =
      targetNodeName === "INPUT" ||
      targetNodeName === "SELECT" ||
      targetNodeName === "TEXTAREA";

    if (isInputTarget) {
      return;
    }

    if (event.key === "Escape") {
      this.onClose(event);
    }
  }

  onClose(event) {
    event.preventDefault();
    this.classList.add("closing");
    this.addEventListener(
      "animationend",
      (event) => {
        if (event.animationName === "fade-out") {
          this.doClose();
        }
      },
      { once: true },
    );
  }

  doClose() {
    this.remove();
    this.dispatchEvent(new CustomEvent("modal:close"));

    // Navigate to close URL
    const closeUrl = this.dataset.closeUrl;
    const frame = this.dataset.turboFrame;
    const action = this.dataset.turboAction || "replace";
    if (closeUrl) {
      Turbo.visit(closeUrl, { action, frame: frame });
    }
  }
}

customElements.define("ld-modal", Modal);


================================================
FILE: bookmarks/frontend/components/search-autocomplete.js
================================================
import { html } from "lit";
import { api } from "../api.js";
import { TurboLitElement } from "../utils/element.js";
import {
  clampText,
  debounce,
  getCurrentWord,
  getCurrentWordBounds,
} from "../utils/input.js";
import { PositionController } from "../utils/position-controller.js";
import { SearchHistory } from "../utils/search-history.js";
import { cache } from "../utils/tag-cache.js";

export class SearchAutocomplete extends TurboLitElement {
  static properties = {
    inputName: { type: String, attribute: "input-name" },
    inputPlaceholder: { type: String, attribute: "input-placeholder" },
    inputValue: { type: String, attribute: "input-value" },
    mode: { type: String },
    user: { type: String },
    shared: { type: String },
    unread: { type: String },
    target: { type: String },
    isFocus: { state: true },
    isOpen: { state: true },
    suggestions: { state: true },
    selectedIndex: { state: true },
  };

  constructor() {
    super();
    this.inputName = "";
    this.inputPlaceholder = "";
    this.inputValue = "";
    this.mode = "";
    this.target = "_blank";
    this.isFocus = false;
    this.isOpen = false;
    this.suggestions = {
      recentSearches: [],
      bookmarks: [],
      tags: [],
      total: [],
    };
    this.selectedIndex = undefined;
    this.input = null;
    this.menu = null;
    this.searchHistory = new SearchHistory();
    this.debouncedLoadSuggestions = debounce(() => this.loadSuggestions());
  }

  firstUpdated() {
    this.style.setProperty("--menu-max-height", "400px");
    this.input = this.querySelector("input");
    this.menu = this.querySelector(".menu");
    // Track current search query after loading the page
    this.searchHistory.pushCurrent();
    this.updateSuggestions();
    this.positionController = new PositionController({
      anchor: this.input,
      overlay: this.menu,
      autoWidth: true,
      placement: "bottom-start",
    });
  }

  disconnectedCallback() {
    super.disconnectedCallback();
    this.close();
  }

  handleFocus() {
    this.isFocus = true;
  }

  handleBlur() {
    this.isFocus = false;
    this.close();
  }

  handleInput(e) {
    this.inputValue = e.target.value;
    this.debouncedLoadSuggestions();
  }

  handleKeyDown(e) {
    // Enter
    if (
      this.isOpen &&
      this.selectedIndex !== undefined &&
      (e.keyCode === 13 || e.keyCode === 9)
    ) {
      const suggestion = this.suggestions.total[this.selectedIndex];
      if (suggestion) this.completeSuggestion(suggestion);
      e.preventDefault();
    }
    // Escape
    if (e.keyCode === 27) {
      this.close();
      e.preventDefault();
    }
    // Up arrow
    if (e.keyCode === 38) {
      this.updateSelection(-1);
      e.preventDefault();
    }
    // Down arrow
    if (e.keyCode === 40) {
      if (!this.isOpen) {
        this.loadSuggestions();
      } else {
        this.updateSelection(1);
      }
      e.preventDefault();
    }
  }

  open() {
    this.isOpen = true;
    this.positionController.enable();
  }

  close() {
    this.isOpen = false;
    this.updateSuggestions();
    this.selectedIndex = undefined;
    this.positionController.disable();
  }

  hasSuggestions() {
    return this.suggestions.total.length > 0;
  }

  async loadSuggestions() {
    let suggestionIndex = 0;

    function nextIndex() {
      return suggestionIndex++;
    }

    // Tag suggestions
    const tags = await cache.getTags();
    let tagSuggestions = [];
    const currentWord = getCurrentWord(this.input);
    if (currentWord && currentWord.length > 1 && currentWord[0] === "#") {
      const searchTag = currentWord.substring(1, currentWord.length);
      tagSuggestions = (tags || [])
        .filter(
          (tag) =>
            tag.name.toLowerCase().indexOf(searchTag.toLowerCase()) === 0,
        )
        .slice(0, 5)
        .map((tag) => ({
          type: "tag",
          index: nextIndex(),
          label: `#${tag.name}`,
          tagName: tag.name,
        }));
    }

    // Recent search suggestions
    const recentSearches = this.searchHistory
      .getRecentSearches(this.inputValue, 5)
      .map((value) => ({
        type: "search",
        index: nextIndex(),
        label: value,
        value,
      }));

    // Bookmark suggestions
    let bookmarks = [];

    if (this.inputValue && this.inputValue.length >= 3) {
      const path = this.mode ? `/${this.mode}` : "";
      const suggestionSearch = {
        user: this.user,
        shared: this.shared,
        unread: this.unread,
        q: this.inputValue,
      };
      const fetchedBookmarks = await api.listBookmarks(suggestionSearch, {
        limit: 5,
        offset: 0,
        path,
      });
      bookmarks = fetchedBookmarks.map((bookmark) => {
        const fullLabel = bookmark.title || bookmark.url;
        const label = clampText(fullLabel, 60);
        return {
          type: "bookmark",
          index: nextIndex(),
          label,
          bookmark,
        };
      });
    }

    this.updateSuggestions(recentSearches, bookmarks, tagSuggestions);

    if (this.hasSuggestions()) {
      this.open();
    } else {
      this.close();
    }
  }

  updateSuggestions(recentSearches, bookmarks, tagSuggestions) {
    recentSearches = recentSearches || [];
    bookmarks = bookmarks || [];
    tagSuggestions = tagSuggestions || [];
    this.suggestions = {
      recentSearches,
      bookmarks,
      tags: tagSuggestions,
      total: [...tagSuggestions, ...recentSearches, ...bookmarks],
    };
  }

  completeSuggestion(suggestion) {
    if (suggestion.type === "search") {
      this.inputValue = suggestion.value;
      this.close();
    }
    if (suggestion.type === "bookmark") {
      window.open(suggestion.bookmark.url, this.target);
      this.close();
    }
    if (suggestion.type === "tag") {
      const bounds = getCurrentWordBounds(this.input);
      const inputValue = this.input.value;
      this.input.value =
        inputValue.substring(0, bounds.start) +
        `#${suggestion.tagName} ` +
        inputValue.substring(bounds.end);
      this.close();
    }
  }

  updateSelection(dir) {
    const length = this.suggestions.total.length;

    if (length === 0) return;

    if (this.selectedIndex === undefined) {
      this.selectedIndex = dir > 0 ? 0 : Math.max(length - 1, 0);
      return;
    }

    let newIndex = this.selectedIndex + dir;

    if (newIndex < 0) newIndex = Math.max(length - 1, 0);
    if (newIndex >= length) newIndex = 0;

    this.selectedIndex = newIndex;
  }

  renderSuggestions(suggestions, title) {
    if (suggestions.length === 0) return "";

    return html`
      <li class="menu-item group-item">${title}</li>
      ${suggestions.map(
        (suggestion) => html`
          <li
            class="menu-item ${this.selectedIndex === suggestion.index
              ? "selected"
              : ""}"
          >
            <a
              href="#"
              @mousedown=${(e) => {
                e.preventDefault();
                this.completeSuggestion(suggestion);
              }}
            >
              ${suggestion.label}
            </a>
          </li>
        `,
      )}
    `;
  }

  render() {
    return html`
      <div class="form-autocomplete">
        <div
          class="form-autocomplete-input form-input ${this.isFocus
            ? "is-focused"
            : ""}"
        >
          <input
            type="search"
            class="form-input"
            name="${this.inputName}"
            placeholder="${this.inputPlaceholder}"
            autocomplete="off"
            .value="${this.inputValue}"
            @input=${this.handleInput}
            @keydown=${this.handleKeyDown}
            @focus=${this.handleFocus}
            @blur=${this.handleBlur}
          />
        </div>

        <ul class="menu ${this.isOpen ? "open" : ""}">
          ${this.renderSuggestions(this.suggestions.tags, "Tags")}
          ${this.renderSuggestions(
            this.suggestions.recentSearches,
            "Recent Searches",
          )}
          ${this.renderSuggestions(this.suggestions.bookmarks, "Bookmarks")}
        </ul>
      </div>
    `;
  }
}

customElements.define("ld-search-autocomplete", SearchAutocomplete);


================================================
FILE: bookmarks/frontend/components/tag-autocomplete.js
================================================
import { html, nothing } from "lit";
import { TurboLitElement } from "../utils/element.js";
import { getCurrentWord, getCurrentWordBounds } from "../utils/input.js";
import { PositionController } from "../utils/position-controller.js";
import { cache } from "../utils/tag-cache.js";

export class TagAutocomplete extends TurboLitElement {
  static properties = {
    inputId: { type: String, attribute: "input-id" },
    inputName: { type: String, attribute: "input-name" },
    inputValue: { type: String, attribute: "input-value" },
    inputClass: { type: String, attribute: "input-class" },
    inputPlaceholder: { type: String, attribute: "input-placeholder" },
    inputAriaDescribedBy: { type: String, attribute: "input-aria-describedby" },
    variant: { type: String },
    isFocus: { state: true },
    isOpen: { state: true },
    suggestions: { state: true },
    selectedIndex: { state: true },
  };

  constructor() {
    super();
    this.inputId = "";
    this.inputName = "";
    this.inputValue = "";
    this.inputPlaceholder = "";
    this.inputAriaDescribedBy = "";
    this.variant = "default";
    this.isFocus = false;
    this.isOpen = false;
    this.suggestions = [];
    this.selectedIndex = 0;
    this.input = null;
    this.suggestionList = null;
  }

  firstUpdated() {
    this.input = this.querySelector("input");
    this.suggestionList = this.querySelector(".menu");
    this.positionController = new PositionController({
      anchor: this.input,
      overlay: this.suggestionList,
      autoWidth: true,
      placement: "bottom-start",
    });
  }

  disconnectedCallback() {
    super.disconnectedCallback();
    this.close();
  }

  handleFocus() {
    this.isFocus = true;
  }

  handleBlur() {
    this.isFocus = false;
    this.close();
  }

  async handleInput(e) {
    this.input = e.target;

    const tags = await cache.getTags();
    const word = getCurrentWord(this.input);

    this.suggestions = word
      ? tags.filter(
          (tag) => tag.name.toLowerCase().indexOf(word.toLowerCase()) === 0,
        )
      : [];

    if (word && this.suggestions.length > 0) {
      this.open();
    } else {
      this.close();
    }
  }

  handleKeyDown(e) {
    if (this.isOpen && (e.keyCode === 13 || e.keyCode === 9)) {
      const suggestion = this.suggestions[this.selectedIndex];
      this.complete(suggestion);
      e.preventDefault();
    }
    if (e.keyCode === 27) {
      this.close();
      e.preventDefault();
    }
    if (e.keyCode === 38) {
      this.updateSelection(-1);
      e.preventDefault();
    }
    if (e.keyCode === 40) {
      this.updateSelection(1);
      e.preventDefault();
    }
  }

  open() {
    this.isOpen = true;
    this.selectedIndex = 0;
    this.positionController.enable();
  }

  close() {
    this.isOpen = false;
    this.suggestions = [];
    this.selectedIndex = 0;
    this.positionController.disable();
  }

  complete(suggestion) {
    const bounds = getCurrentWordBounds(this.input);
    const value = this.input.value;
    this.input.value =
      value.substring(0, bounds.start) +
      suggestion.name +
      " " +
      value.substring(bounds.end);
    this.dispatchEvent(new CustomEvent("input", { bubbles: true }));

    this.close();
  }

  updateSelection(dir) {
    const length = this.suggestions.length;
    let newIndex = this.selectedIndex + dir;

    if (newIndex < 0) newIndex = Math.max(length - 1, 0);
    if (newIndex >= length) newIndex = 0;

    this.selectedIndex = newIndex;

    // Scroll to selected list item
    setTimeout(() => {
      if (this.suggestionList) {
        const selectedListItem =
          this.suggestionList.querySelector("li.selected");
        if (selectedListItem) {
          selectedListItem.scrollIntoView({ block: "center" });
        }
      }
    }, 0);
  }

  render() {
    return html`
      <div class="form-autocomplete ${this.variant === "small" ? "small" : ""}">
        <!-- autocomplete input container -->
        <div
          class="form-autocomplete-input form-input ${this.isFocus
            ? "is-focused"
            : ""}"
        >
          <!-- autocomplete real input box -->
          <input
            id="${this.inputId || nothing}"
            name="${this.inputName || nothing}"
            .value="${this.inputValue || ""}"
            placeholder="${this.inputPlaceholder || " "}"
            class="form-input ${this.inputClass || ""}"
            type="text"
            autocomplete="off"
            autocapitalize="off"
            aria-describedby="${this.inputAriaDescribedBy || nothing}"
            @input=${this.handleInput}
            @keydown=${this.handleKeyDown}
            @focus=${this.handleFocus}
            @blur=${this.handleBlur}
          />
        </div>

        <!-- autocomplete suggestion list -->
        <ul
          class="menu ${this.isOpen && this.suggestions.length > 0
            ? "open"
            : ""}"
        >
          <!-- menu list items -->
          ${this.suggestions.map(
            (tag, i) => html`
              <li
                class="menu-item ${this.selectedIndex === i ? "selected" : ""}"
              >
                <a
                  href="#"
                  @mousedown=${(e) => {
                    e.preventDefault();
                    this.complete(tag);
                  }}
                >
                  ${tag.name}
                </a>
              </li>
            `,
          )}
        </ul>
      </div>
    `;
  }
}

customElements.define("ld-tag-autocomplete", TagAutocomplete);


================================================
FILE: bookmarks/frontend/components/upload-button.js
================================================
import { HeadlessElement } from "../utils/element.js";

class UploadButton extends HeadlessElement {
  init() {
    this.onClick = this.onClick.bind(this);
    this.onChange = this.onChange.bind(this);

    this.button = this.querySelector('button[type="submit"]');
    this.button.addEventListener("click", this.onClick);

    this.fileInput = this.querySelector('input[type="file"]');
    this.fileInput.addEventListener("change", this.onChange);
  }

  onClick(event) {
    event.preventDefault();
    this.fileInput.click();
  }

  onChange() {
    // Check if the file input has a file selected
    if (!this.fileInput.files.length) {
      return;
    }
    this.closest("form").requestSubmit(this.button);
    // remove selected file so it doesn't get submitted again
    this.fileInput.value = "";
  }
}

customElements.define("ld-upload-button", UploadButton);


================================================
FILE: bookmarks/frontend/index.js
================================================
import "@hotwired/turbo";
import "./components/bookmark-page.js";
import "./components/clear-button.js";
import "./components/confirm-dropdown.js";
import "./components/details-modal.js";
import "./components/dev-tool.js";
import "./components/dropdown.js";
import "./components/filter-drawer.js";
import "./components/form.js";
import "./components/modal.js";
import "./components/search-autocomplete.js";
import "./components/tag-autocomplete.js";
import "./components/upload-button.js";
import "./shortcuts.js";


================================================
FILE: bookmarks/frontend/shortcuts.js
================================================
document.addEventListener("keydown", (event) => {
  // Skip if event occurred within an input element
  const targetNodeName = event.target.nodeName;
  const isInputTarget =
    targetNodeName === "INPUT" ||
    targetNodeName === "SELECT" ||
    targetNodeName === "TEXTAREA";

  if (isInputTarget) {
    return;
  }

  // Handle shortcuts for navigating bookmarks with arrow keys
  const isArrowUp = event.key === "ArrowUp";
  const isArrowDown = event.key === "ArrowDown";
  if (isArrowUp || isArrowDown) {
    event.preventDefault();

    // Detect current bookmark list item
    const items = [...document.querySelectorAll("ul.bookmark-list > li")];
    const path = event.composedPath();
    const currentItem = path.find((item) => items.includes(item));

    // Find next item
    let nextItem;
    if (currentItem) {
      nextItem = isArrowUp
        ? currentItem.previousElementSibling
        : currentItem.nextElementSibling;
    } else {
      // Select first item
      nextItem = items[0];
    }
    // Focus first link
    if (nextItem) {
      nextItem.querySelector("a").focus();
    }
  }

  // Handle shortcut for toggling all notes
  if (event.key === "e") {
    const list = document.querySelector(".bookmark-list");
    if (list) {
      list.classList.toggle("show-notes");
    }
  }

  // Handle shortcut for focusing search input
  if (event.key === "s") {
    const searchInput = document.querySelector('input[type="search"]');

    if (searchInput) {
      searchInput.focus();
      event.preventDefault();
    }
  }

  // Handle shortcut for adding new bookmark
  if (event.key === "n") {
    window.location.assign("/bookmarks/new");
  }
});


================================================
FILE: bookmarks/frontend/utils/element.js
================================================
import { LitElement } from "lit";

/**
 * Base class for custom elements that wrap existing server-rendered DOM.
 *
 * Handles timing issues where connectedCallback fires before child elements
 * are parsed during initial page load. With Turbo navigation, children are
 * always available, but on fresh page loads they may not be.
 *
 * Subclasses should override init() instead of connectedCallback().
 */
export class HeadlessElement extends HTMLElement {
  connectedCallback() {
    if (this.__initialized) {
      return;
    }
    this.__initialized = true;
    if (document.readyState === "loading") {
      document.addEventListener("turbo:load", () => this.init(), {
        once: true,
      });
    } else {
      this.init();
    }
  }

  init() {
    // Override in subclass
  }
}

let isTopFrameVisit = false;

document.addEventListener("turbo:visit", (event) => {
  const url = event.detail.url;
  isTopFrameVisit =
    document.querySelector(`turbo-frame[src="${url}"][target="_top"]`) !== null;
});

document.addEventListener("turbo:render", () => {
  isTopFrameVisit = false;
});

document.addEventListener("turbo:before-morph-element", (event) => {
  const parent = event.target?.parentElement;
  if (parent instanceof TurboLitElement) {
    // Prevent Turbo from morphing Lit elements contents, which would remove
    // elements rendered on the client side.
    event.preventDefault();
  }
});

export class TurboLitElement extends LitElement {
  constructor() {
    super();
    this.__prepareForCache = this.__prepareForCache.bind(this);
  }

  createRenderRoot() {
    return this; // Render to light DOM
  }

  connectedCallback() {
    document.addEventListener("turbo:before-cache", this.__prepareForCache);
    super.connectedCallback();
  }

  disconnectedCallback() {
    document.removeEventListener("turbo:before-cache", this.__prepareForCache);
    super.disconnectedCallback();
  }

  __prepareForCache() {
    // Remove rendered contents before caching, otherwise restoring the DOM from
    // cache will result in duplicated contents. Turbo also fires before-cache
    // when rendering a frame that does target the top frame, in which case we
    // want to keep the contents.
    if (!isTopFrameVisit) {
      this.innerHTML = "";
    }
  }
}


================================================
FILE: bookmarks/frontend/utils/focus.js
================================================
let keyboardActive = false;

window.addEventListener(
  "keydown",
  () => {
    keyboardActive = true;
  },
  { capture: true },
);

window.addEventListener(
  "mousedown",
  () => {
    keyboardActive = false;
  },
  { capture: true },
);

export function isKeyboardActive() {
  return keyboardActive;
}

export class FocusTrapController {
  constructor(element) {
    this.element = element;
    this.focusableElements = this.element.querySelectorAll(
      'a[href]:not([disabled]), button:not([disabled]), textarea:not([disabled]), input[type="text"]:not([disabled]), input[type="radio"]:not([disabled]), input[type="checkbox"]:not([disabled]), select:not([disabled])',
    );
    this.firstFocusableElement = this.focusableElements[0];
    this.lastFocusableElement =
      this.focusableElements[this.focusableElements.length - 1];

    this.onKeyDown = this.onKeyDown.bind(this);

    this.firstFocusableElement.focus({ focusVisible: keyboardActive });
    this.element.addEventListener("keydown", this.onKeyDown);
  }

  destroy() {
    this.element.removeEventListener("keydown", this.onKeyDown);
  }

  onKeyDown(event) {
    if (event.key !== "Tab") {
      return;
    }
    if (event.shiftKey) {
      if (document.activeElement === this.firstFocusableElement) {
        event.preventDefault();
        this.lastFocusableElement.focus();
      }
    } else {
      if (document.activeElement === this.lastFocusableElement) {
        event.preventDefault();
        this.firstFocusableElement.focus();
      }
    }
  }
}

let afterPageLoadFocusTarget = [];
let firstPageLoad = true;

export function setAfterPageLoadFocusTarget(...targets) {
  afterPageLoadFocusTarget = targets;
}

function programmaticFocus(element) {
  // Ensure element is focusable
  // Hide focus outline if element is not focusable by default - might
  // reconsider this later
  const isFocusable = element.tabIndex >= 0;
  if (!isFocusable) {
    // Apparently the default tabIndex is -1, even though an element is still
    // not focusable with that. Setting an explicit -1 also sets the attribute
    // and the element becomes focusable.
    element.tabIndex = -1;
    // `focusVisible` is not supported in all browsers, so hide the outline manually
    element.style["outline"] = "none";
  }
  element.focus({
    focusVisible: isKeyboardActive() && isFocusable,
    preventScroll: true,
  });
}

// Register global listener for navigation and try to focus an element that
// results in a meaningful announcement.
document.addEventListener("turbo:load", () => {
  // Ignore initial page load to let the browser handle announcements
  if (firstPageLoad) {
    firstPageLoad = false;
    return;
  }

  // Ignore if there is a modal dialog, which should handle its own focus
  const modal = document.querySelector("[aria-modal='true']");
  if (modal) {
    return;
  }

  // Check if there is an explicit focus target for the next page load
  for (const target of afterPageLoadFocusTarget) {
    const element = document.querySelector(target);
    if (element) {
      programmaticFocus(element);
      return;
    }
  }
  afterPageLoadFocusTarget = [];

  // If there is some autofocus element, let the browser handle it
  const autofocus = document.querySelector("[autofocus]");
  if (autofocus) {
    return;
  }

  // If there is a toast as a result of some action, focus it
  const toast = document.querySelector(".toast");
  if (toast) {
    programmaticFocus(toast);
    return;
  }

  // Otherwise go with main
  const main = document.querySelector("main");
  if (main) {
    programmaticFocus(main);
  }
});


================================================
FILE: bookmarks/frontend/utils/input.js
================================================
export function debounce(callback, delay = 250) {
  let timeoutId;
  return (...args) => {
    clearTimeout(timeoutId);
    timeoutId = setTimeout(() => {
      timeoutId = null;
      callback(...args);
    }, delay);
  };
}

export function clampText(text, maxChars = 30) {
  if (!text || text.length <= 30) return text;

  return text.substr(0, maxChars) + "...";
}

export function getCurrentWordBounds(input) {
  const text = input.value;
  const end = input.selectionStart;
  let start = end;

  let currentChar = text.charAt(start - 1);

  while (currentChar && currentChar !== " " && start > 0) {
    start--;
    currentChar = text.charAt(start - 1);
  }

  return { start, end };
}

export function getCurrentWord(input) {
  const bounds = getCurrentWordBounds(input);

  return input.value.substring(bounds.start, bounds.end);
}


================================================
FILE: bookmarks/frontend/utils/position-controller.js
================================================
import {
  arrow,
  autoUpdate,
  computePosition,
  flip,
  offset,
  shift,
} from "@floating-ui/dom";

export class PositionController {
  constructor(options) {
    this.anchor = options.anchor;
    this.overlay = options.overlay;
    this.arrow = options.arrow;
    this.placement = options.placement || "bottom";
    this.offset = options.offset;
    this.autoWidth = options.autoWidth || false;
    this.autoUpdateCleanup = null;
  }

  enable() {
    if (!this.autoUpdateCleanup) {
      this.autoUpdateCleanup = autoUpdate(this.anchor, this.overlay, () =>
        this.updatePosition(),
      );
    }
  }

  disable() {
    if (this.autoUpdateCleanup) {
      this.autoUpdateCleanup();
      this.autoUpdateCleanup = null;
    }
  }

  updatePosition() {
    const middleware = [flip(), shift()];
    if (this.arrow) {
      middleware.push(arrow({ element: this.arrow }));
    }
    if (this.offset) {
      middleware.push(offset(this.offset));
    }
    computePosition(this.anchor, this.overlay, {
      placement: this.placement,
      strategy: "fixed",
      middleware,
    }).then(({ x, y, placement, middlewareData }) => {
      Object.assign(this.overlay.style, {
        left: `${x}px`,
        top: `${y}px`,
      });

      this.overlay.classList.remove("top-aligned", "bottom-aligned");
      this.overlay.classList.add(`${placement}-aligned`);

      if (this.arrow) {
        const { x, y } = middlewareData.arrow;
        Object.assign(this.arrow.style, {
          left: x != null ? `${x}px` : "",
          top: y != null ? `${y}px` : "",
        });
      }
    });

    if (this.autoWidth) {
      const width = this.anchor.offsetWidth;
      this.overlay.style.width = `${width}px`;
    }
  }
}


================================================
FILE: bookmarks/frontend/utils/search-history.js
================================================
const SEARCH_HISTORY_KEY = "searchHistory";
const MAX_ENTRIES = 30;

export class SearchHistory {
  getHistory() {
    const historyJson = localStorage.getItem(SEARCH_HISTORY_KEY);
    return historyJson
      ? JSON.parse(historyJson)
      : {
          recent: [],
        };
  }

  pushCurrent() {
    // Skip if browser is not compatible
    if (!window.URLSearchParams) return;
    const urlParams = new URLSearchParams(window.location.search);
    const searchParam = urlParams.get("q");

    if (!searchParam) return;

    this.push(searchParam);
  }

  push(search) {
    const history = this.getHistory();

    history.recent.unshift(search);

    // Remove duplicates and clamp to max entries
    history.recent = history.recent.reduce((acc, cur) => {
      if (acc.length >= MAX_ENTRIES) return acc;
      if (acc.indexOf(cur) >= 0) return acc;
      acc.push(cur);
      return acc;
    }, []);

    const newHistoryJson = JSON.stringify(history);
    localStorage.setItem(SEARCH_HISTORY_KEY, newHistoryJson);
  }

  getRecentSearches(query, max) {
    const history = this.getHistory();

    return history.recent
      .filter(
        (search) =>
          !query || search.toLowerCase().indexOf(query.toLowerCase()) >= 0,
      )
      .slice(0, max);
  }
}


================================================
FILE: bookmarks/frontend/utils/tag-cache.js
================================================
import { api } from "../api.js";

class TagCache {
  constructor(api) {
    this.api = api;

    // Reset cached tags after a form submission
    document.addEventListener("turbo:submit-end", () => {
      this.tagsPromise = null;
    });
  }

  getTags() {
    if (!this.tagsPromise) {
      this.tagsPromise = this.api
        .getTags({
          limit: 5000,
          offset: 0,
        })
        .then((tags) =>
          tags.sort((left, right) =>
            left.name.toLowerCase().localeCompare(right.name.toLowerCase()),
          ),
        )
        .catch((e) => {
          console.warn("Cache: Error loading tags", e);
          return [];
        });
    }

    return this.tagsPromise;
  }
}

export const cache = new TagCache(api);


================================================
FILE: bookmarks/management/commands/backup.py
================================================
import os
import sqlite3

from django.core.management.base import BaseCommand


class Command(BaseCommand):
    help = "Creates a backup of the linkding database"

    def add_arguments(self, parser):
        parser.add_argument("destination", type=str, help="Backup file destination")

    def handle(self, *args, **options):
        destination = options["destination"]

        def progress(status, remaining, total):
            self.stdout.write(f"Copied {total - remaining} of {total} pages...")

        source_db = sqlite3.connect(os.path.join("data", "db.sqlite3"))
        backup_db = sqlite3.connect(destination)
        with backup_db:
            source_db.backup(backup_db, pages=50, progress=progress)
        backup_db.close()
        source_db.close()

        self.stdout.write(self.style.SUCCESS(f"Backup created at {destination}"))
        self.stdout.write(
            self.style.WARNING(
                "This backup method is deprecated and may be removed in the future. Please use the full_backup command instead, which creates backup zip file with all contents of the data folder."
            )
        )


================================================
FILE: bookmarks/management/commands/create_initial_superuser.py
================================================
import logging
import os

from django.contrib.auth import get_user_model
from django.core.management.base import BaseCommand

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")


================================================
FILE: bookmarks/management/commands/enable_wal.py
================================================
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 not settings.USE_SQLITE:
            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")


================================================
FILE: bookmarks/management/commands/ensure_superuser.py
================================================
from django.contrib.auth import get_user_model
from django.core.management.base import BaseCommand


class Command(BaseCommand):
    help = "Creates an admin user non-interactively if it doesn't exist"

    def add_arguments(self, parser):
        parser.add_argument("--username", help="Admin's username")
        parser.add_argument("--email", help="Admin's email")
        parser.add_argument("--password", help="Admin's password")

    def handle(self, *args, **options):
        User = get_user_model()
        if not User.objects.filter(username=options["username"]).exists():
            User.objects.create_superuser(
                username=options["username"],
                email=options["email"],
                password=options["password"],
            )


================================================
FILE: bookmarks/management/commands/full_backup.py
================================================
import os
import sqlite3
import tempfile
import zipfile

from django.core.management.base import BaseCommand


class Command(BaseCommand):
    help = "Creates a backup of the linkding data folder"

    def add_arguments(self, parser):
        parser.add_argument("backup_file", type=str, help="Backup zip file destination")

    def handle(self, *args, **options):
        backup_file = options["backup_file"]
        with zipfile.ZipFile(backup_file, "w", zipfile.ZIP_DEFLATED) as zip_file:
            # Backup the database
            self.stdout.write("Create database backup...")
            with tempfile.TemporaryDirectory() as temp_dir:
                backup_db_file = os.path.join(temp_dir, "db.sqlite3")
                self.backup_database(backup_db_file)
                zip_file.write(backup_db_file, "db.sqlite3")

            # Backup the assets folder
            if not os.path.exists(os.path.join("data", "assets")):
                self.stdout.write(
                    self.style.WARNING("No assets folder found. Skipping...")
                )
            else:
                self.stdout.write("Backup bookmark assets...")
                assets_folder = os.path.join("data", "assets")
                for root, _, files in os.walk(assets_folder):
                    for file in files:
                        file_path = os.path.join(root, file)
                        zip_file.write(file_path, os.path.join("assets", file))

            # Backup the favicons folder
            if not os.path.exists(os.path.join("data", "favicons")):
                self.stdout.write(
                    self.style.WARNING("No favicons folder found. Skipping...")
                )
            else:
                self.stdout.write("Backup bookmark favicons...")
                favicons_folder = os.path.join("data", "favicons")
                for root, _, files in os.walk(favicons_folder):
                    for file in files:
                        file_path = os.path.join(root, file)
                        zip_file.write(file_path, os.path.join("favicons", file))

            # Backup the previews folder
            if not os.path.exists(os.path.join("data", "previews")):
                self.stdout.write(
                    self.style.WARNING("No previews folder found. Skipping...")
                )
            else:
                self.stdout.write("Backup bookmark previews...")
                previews_folder = os.path.join("data", "previews")
                for root, _, files in os.walk(previews_folder):
                    for file in files:
                        file_path = os.path.join(root, file)
                        zip_file.write(file_path, os.path.join("previews", file))

        self.stdout.write(self.style.SUCCESS(f"Backup created at {backup_file}"))

    def backup_database(self, backup_db_file):
        def progress(status, remaining, total):
            self.stdout.write(f"Copied {total - remaining} of {total} pages...")

        source_db = sqlite3.connect(os.path.join("data", "db.sqlite3"))
        backup_db = sqlite3.connect(backup_db_file)
        with backup_db:
            source_db.backup(backup_db, pages=50, progress=progress)
        backup_db.close()
        source_db.close()


================================================
FILE: bookmarks/management/commands/generate_secret_key.py
================================================
import logging
import os

from django.core.management.base import BaseCommand
from django.core.management.utils import get_random_secret_key

logger = logging.getLogger(__name__)


class Command(BaseCommand):
    help = "Generate secret key file if it does not exist"

    def handle(self, *args, **options):
        secret_key_file = os.path.join("data", "secretkey.txt")

        if os.path.exists(secret_key_file):
            logger.info("Secret key file already exists")
            return

        secret_key = get_random_secret_key()
        with open(secret_key_file, "w") as f:
            f.write(secret_key)
        logger.info("Generated secret key file")


================================================
FILE: bookmarks/management/commands/import_netscape.py
================================================
from django.contrib.auth.models import User
from django.core.management.base import BaseCommand

from bookmarks.services.importer import import_netscape_html


class Command(BaseCommand):
    help = "Import Netscape HTML bookmark file"

    def add_arguments(self, parser):
        parser.add_argument("file", type=str, help="Path to file")
        parser.add_argument(
            "user", type=str, help="Name of the user for which to import"
        )

    def handle(self, *args, **kwargs):
        filepath = kwargs["file"]
        username = kwargs["user"]
        with open(filepath) as html_file:
            html = html_file.read()
        user = User.objects.get(username=username)

        import_netscape_html(html, user)


================================================
FILE: bookmarks/management/commands/migrate_tasks.py
================================================
import importlib
import json
import os
import sqlite3

from django.core.management.base import BaseCommand


class Command(BaseCommand):
    help = "Migrate tasks from django-background-tasks to Huey"

    def handle(self, *args, **options):
        db = sqlite3.connect(os.path.join("data", "db.sqlite3"))

        # Check if background_task table exists
        cursor = db.cursor()
        cursor.execute(
            "SELECT name FROM sqlite_master WHERE type='table' AND name='background_task'"
        )
        row = cursor.fetchone()
        if not row:
            self.stdout.write(
                "Legacy task table does not exist. Skipping task migration"
            )
            return

        # Load legacy tasks
        cursor.execute("SELECT id, task_name, task_params FROM background_task")
        legacy_tasks = cursor.fetchall()

        if len(legacy_tasks) == 0:
            self.stdout.write("No legacy tasks found. Skipping task migration")
            return

        self.stdout.write(
            f"Found {len(legacy_tasks)} legacy tasks. Migrating to Huey..."
        )

        # Migrate tasks to Huey
        succeeded_tasks = []
        for task in legacy_tasks:
            task_id = task[0]
            task_name = task[1]
            task_params_json = task[2]
            try:
                task_params = json.loads(task_params_json)
                function_params = task_params[0]

                # Resolve task function
                module_name, func_name = task_name.rsplit(".", 1)
                module = importlib.import_module(module_name)
                func = getattr(module, func_name)

                # Call task function
                func(*function_params)
                succeeded_tasks.append(task_id)
            except Exception:
                self.stderr.write(f"Error migrating task [{task_id}] {task_name}")

        self.stdout.write(f"Migrated {len(succeeded_tasks)} tasks successfully")

        # Clean up
        try:
            placeholders = ", ".join("?" for _ in succeeded_tasks)
            sql = f"DELETE FROM background_task WHERE id IN ({placeholders})"
            cursor.execute(sql, succeeded_tasks)
            db.commit()
            self.stdout.write(
                f"Deleted {len(succeeded_tasks)} migrated tasks from legacy table"
            )
        except Exception:
            self.stderr.write("Error cleaning up legacy tasks")

        cursor.close()
        db.close()


================================================
FILE: bookmarks/middlewares.py
================================================
from django.conf import settings
from django.contrib.auth.middleware import RemoteUserMiddleware

from bookmarks.models import GlobalSettings, UserProfile


class CustomRemoteUserMiddleware(RemoteUserMiddleware):
    header = settings.LD_AUTH_PROXY_USERNAME_HEADER


default_global_settings = GlobalSettings()

standard_profile = UserProfile()
standard_profile.enable_favicons = True


class LinkdingMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        # add global settings to request
        try:
            global_settings = GlobalSettings.get()
        except Exception:
            global_settings = default_global_settings
        request.global_settings = global_settings

        # add user profile to request
        if request.user.is_authenticated:
            request.user_profile = request.user.profile
        else:
            # check if a custom profile for guests exists, otherwise use standard profile
            if global_settings.guest_profile_user:
                request.user_profile = global_settings.guest_profile_user.profile
            else:
                request.user_profile = standard_profile

        response = self.get_response(request)

        return response


================================================
FILE: bookmarks/migrations/0001_initial.py
================================================
# Generated by Django 2.2.2 on 2019-06-28 23:49

import django.db.models.deletion
from django.conf import settings
from django.db import migrations, models


class Migration(migrations.Migration):
    initial = True

    dependencies = [
        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
    ]

    operations = [
        migrations.CreateModel(
            name="Bookmark",
            fields=[
                (
                    "id",
                    models.AutoField(
                        auto_created=True,
                        primary_key=True,
                        serialize=False,
                        verbose_name="ID",
                    ),
                ),
                ("url", models.URLField()),
                ("title", models.CharField(max_length=512)),
                ("description", models.TextField()),
                (
                    "website_title",
                    models.CharField(blank=True, max_length=512, null=True),
                ),
                ("website_description", models.TextField(blank=True, null=True)),
                ("unread", models.BooleanField(default=True)),
                ("date_added", models.DateTimeField()),
                ("date_modified", models.DateTimeField()),
                ("date_accessed", models.DateTimeField(blank=True, null=True)),
                (
                    "owner",
                    models.ForeignKey(
                        on_delete=django.db.models.deletion.CASCADE,
                        to=settings.AUTH_USER_MODEL,
                    ),
                ),
            ],
        ),
    ]


================================================
FILE: bookmarks/migrations/0002_auto_20190629_2303.py
================================================
# Generated by Django 2.2.2 on 2019-06-29 23:03

import django.db.models.deletion
from django.conf import settings
from django.db import migrations, models


class Migration(migrations.Migration):
    dependencies = [
        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
        ("bookmarks", "0001_initial"),
    ]

    operations = [
        migrations.CreateModel(
            name="Tag",
            fields=[
                (
                    "id",
                    models.AutoField(
                        auto_created=True,
                        primary_key=True,
                        serialize=False,
                        verbose_name="ID",
                    ),
                ),
                ("name", models.CharField(max_length=64)),
                ("date_added", models.DateTimeField()),
                (
                    "owner",
                    models.ForeignKey(
                        on_delete=django.db.models.deletion.CASCADE,
                        to=settings.AUTH_USER_MODEL,
                    ),
                ),
            ],
        ),
        migrations.AddField(
            model_name="bookmark",
            name="tags",
            field=models.ManyToManyField(to="bookmarks.Tag"),
        ),
    ]


================================================
FILE: bookmarks/migrations/0003_auto_20200913_0656.py
================================================
# Generated by Django 2.2.13 on 2020-09-13 06:56

from django.db import migrations, models


class Migration(migrations.Migration):
    dependencies = [
        ("bookmarks", "0002_auto_20190629_2303"),
    ]

    operations = [
        migrations.AlterField(
            model_name="bookmark",
            name="url",
            field=models.URLField(max_length=2048),
        ),
    ]


================================================
FILE: bookmarks/migrations/0004_auto_20200926_1028.py
================================================
# Generated by Django 2.2.13 on 2020-09-26 10:28

from django.db import migrations, models


class Migration(migrations.Migration):
    dependencies = [
        ("bookmarks", "0003_auto_20200913_0656"),
    ]

    operations = [
        migrations.AlterField(
            model_name="bookmark",
            name="description",
            field=models.TextField(blank=True),
        ),
        migrations.AlterField(
            model_name="bookmark",
            name="title",
            field=models.CharField(blank=True, max_length=512),
        ),
    ]


================================================
FILE: bookmarks/migrations/0005_auto_20210103_1212.py
================================================
# Generated by Django 2.2.13 on 2021-01-03 12:12

from django.db import migrations, models

import bookmarks.validators


class Migration(migrations.Migration):
    dependencies = [
        ("bookmarks", "0004_auto_20200926_1028"),
    ]

    operations = [
        migrations.AlterField(
            model_name="bookmark",
            name="url",
            field=models.CharField(
                max_length=2048,
                validators=[bookmarks.validators.BookmarkURLValidator()],
            ),
        ),
    ]


================================================
FILE: bookmarks/migrations/0006_bookmark_is_archived.py
================================================
# Generated by Django 2.2.13 on 2021-02-14 09:08

from django.db import migrations, models


class Migration(migrations.Migration):
    dependencies = [
        ("bookmarks", "0005_auto_20210103_1212"),
    ]

    operations = [
        migrations.AddField(
            model_name="bookmark",
            name="is_archived",
            field=models.BooleanField(default=False),
        ),
    ]


================================================
FILE: bookmarks/migrations/0007_userprofile.py
================================================
# Generated by Django 2.2.18 on 2021-03-26 22:39

import django.db.models.deletion
from django.conf import settings
from django.db import migrations, models


def forwards(apps, schema_editor):
    User = apps.get_model("auth", "User")
    UserProfile = apps.get_model("bookmarks", "UserProfile")
    for user in User.objects.all():
        try:
            if user.profile:
                continue
        except UserProfile.DoesNotExist:
            profile = UserProfile(user=user)
            profile.save()


def reverse(apps, schema_editor):
    pass


class Migration(migrations.Migration):
    dependencies = [
        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
        ("bookmarks", "0006_bookmark_is_archived"),
    ]

    operations = [
        migrations.CreateModel(
            name="UserProfile",
            fields=[
                (
                    "id",
                    models.AutoField(
                        auto_created=True,
                        primary_key=True,
                        serialize=False,
                        verbose_name="ID",
                    ),
                ),
                (
                    "theme",
                    models.CharField(
                        choices=[
                            ("auto", "Auto"),
                            ("light", "Light"),
                            ("dark", "Dark"),
                        ],
                        default="auto",
                        max_length=10,
                    ),
                ),
                (
                    "user",
                    models.OneToOneField(
                        on_delete=django.db.models.deletion.CASCADE,
                        related_name="profile",
                        to=settings.AUTH_USER_MODEL,
                    ),
                ),
            ],
        ),
        migrations.RunPython(forwards, reverse),
    ]


================================================
FILE: bookmarks/migrations/0008_userprofile_bookmark_date_display.py
================================================
# Generated by Django 2.2.18 on 2021-03-30 10:40

from django.db import migrations, models


class Migration(migrations.Migration):
    dependencies = [
        ("bookmarks", "0007_userprofile"),
    ]

    operations = [
        migrations.AddField(
            model_name="userprofile",
            name="bookmark_date_display",
            field=models.CharField(
                choices=[
                    ("relative", "Relative"),
                    ("absolute", "Absolute"),
                    ("hidden", "Hidden"),
                ],
                default="relative",
                max_length=10,
            ),
        ),
    ]


================================================
FILE: bookmarks/migrations/0009_bookmark_web_archive_snapshot_url.py
================================================
# Generated by Django 2.2.20 on 2021-05-16 14:35

from django.db import migrations, models


class Migration(migrations.Migration):
    dependencies = [
        ("bookmarks", "0008_userprofile_bookmark_date_display"),
    ]

    operations = [
        migrations.AddField(
            model_name="bookmark",
            name="web_archive_snapshot_url",
            field=models.CharField(blank=True, max_length=2048),
        ),
    ]


================================================
FILE: bookmarks/migrations/0010_userprofile_bookmark_link_target.py
================================================
# Generated by Django 3.2.6 on 2021-10-03 06:35

from django.db import migrations, models


class Migration(migrations.Migration):
    dependencies = [
        ("bookmarks", "0009_bookmark_web_archive_snapshot_url"),
    ]

    operations = [
        migrations.AddField(
            model_name="userprofile",
            name="bookmark_link_target",
            field=models.CharField(
                choices=[("_blank", "New page"), ("_self", "Same page")],
                default="_blank",
                max_length=10,
            ),
        ),
    ]


================================================
FILE: bookmarks/migrations/0011_userprofile_web_archive_integration.py
================================================
# Generated by Django 3.2.6 on 2022-01-08 12:39

from django.db import migrations, models


class Migration(migrations.Migration):
    dependencies = [
        ("bookmarks", "0010_userprofile_bookmark_link_target"),
    ]

    operations = [
        migrations.AddField(
            model_name="userprofile",
            name="web_archive_integration",
            field=models.CharField(
                choices=[("disabled", "Disabled"), ("enabled", "Enabled")],
                default="disabled",
                max_length=10,
            ),
        ),
    ]


================================================
FILE: bookmarks/migrations/0012_toast.py
================================================
# Generated by Django 3.2.6 on 2022-01-08 19:24

import django.db.models.deletion
from django.conf import settings
from django.db import migrations, models


class Migration(migrations.Migration):
    dependencies = [
        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
        ("bookmarks", "0011_userprofile_web_archive_integration"),
    ]

    operations = [
        migrations.CreateModel(
            name="Toast",
            fields=[
                (
                    "id",
                    models.AutoField(
                        auto_created=True,
                        primary_key=True,
                        serialize=False,
                        verbose_name="ID",
                    ),
                ),
                ("key", models.CharField(max_length=50)),
                ("message", models.TextField()),
                ("acknowledged", models.BooleanField(default=False)),
                (
                    "owner",
                    models.ForeignKey(
                        on_delete=django.db.models.deletion.CASCADE,
                        to=settings.AUTH_USER_MODEL,
                    ),
                ),
            ],
        ),
    ]


================================================
FILE: bookmarks/migrations/0013_web_archive_optin_toast.py
================================================
# Generated by Django 3.2.6 on 2022-01-08 19:27

from django.contrib.auth import get_user_model
from django.db import migrations

from bookmarks.models import Toast

User = get_user_model()


def forwards(apps, schema_editor):
    for user in User.objects.all():
        toast = Toast(
            key="web_archive_opt_in_hint",
            message="The Internet Archive Wayback Machine integration has been disabled by default. Check the Settings to re-enable it.",
            owner=user,
        )
        toast.save()


def reverse(apps, schema_editor):
    Toast.objects.filter(key="web_archive_opt_in_hint").delete()


class Migration(migrations.Migration):
    dependencies = [
        ("bookmarks", "0012_toast"),
    ]

    operations = [
        migrations.RunPython(forwards, reverse),
    ]


================================================
FILE: bookmarks/migrations/0014_alter_bookmark_unread.py
================================================
# 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),
    ]


================================================
FILE: bookmarks/migrations/0015_feedtoken.py
================================================
# Generated by Django 3.2.13 on 2022-07-23 20:35

import django.db.models.deletion
from django.conf import settings
from django.db import migrations, models


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,
                    ),
                ),
            ],
        ),
    ]


================================================
FILE: bookmarks/migrations/0016_bookmark_shared.py
================================================
# 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),
        ),
    ]


================================================
FILE: bookmarks/migrations/0017_userprofile_enable_sharing.py
================================================
# 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),
        ),
    ]


================================================
FILE: bookmarks/migrations/0018_bookmark_favicon_file.py
================================================
# 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),
        ),
    ]


================================================
FILE: bookmarks/migrations/0019_userprofile_enable_favicons.py
================================================
# 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),
        ),
    ]


================================================
FILE: bookmarks/migrations/0020_userprofile_tag_search.py
================================================
# 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,
            ),
        ),
    ]


================================================
FILE: bookmarks/migrations/0021_userprofile_display_url.py
================================================
# 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),
        ),
    ]


================================================
FILE: bookmarks/migrations/0022_bookmark_notes.py
================================================
# 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),
        ),
    ]


================================================
FILE: bookmarks/migrations/0023_userprofile_permanent_notes.py
================================================
# 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),
        ),
    ]


================================================
FILE: bookmarks/migrations/0024_userprofile_enable_public_sharing.py
================================================
# Generated by Django 4.1.9 on 2023-08-14 07:08

from django.db import migrations, models


class Migration(migrations.Migration):
    dependencies = [
        ("bookmarks", "0023_userprofile_permanent_notes"),
    ]

    operations = [
        migrations.AddField(
            model_name="userprofile",
            name="enable_public_sharing",
            field=models.BooleanField(default=False),
        ),
    ]


================================================
FILE: bookmarks/migrations/0025_userprofile_search_preferences.py
================================================
# Generated by Django 4.1.9 on 2023-09-30 10:44

from django.db import migrations, models


class Migration(migrations.Migration):
    dependencies = [
        ("bookmarks", "0024_userprofile_enable_public_sharing"),
    ]

    operations = [
        migrations.AddField(
            model_name="userprofile",
            name="search_preferences",
            field=models.JSONField(default=dict),
        ),
    ]


================================================
FILE: bookmarks/migrations/0026_userprofile_custom_css.py
================================================
# Generated by Django 5.0.2 on 2024-03-16 23:05

from django.db import migrations, models


class Migration(migrations.Migration):
    dependencies = [
        ("bookmarks", "0025_userprofile_search_preferences"),
    ]

    operations = [
        migrations.AddField(
            model_name="userprofile",
            name="custom_css",
            field=models.TextField(blank=True),
        ),
    ]


================================================
FILE: bookmarks/migrations/0027_userprofile_bookmark_description_display_and_more.py
================================================
# Generated by Django 5.0.2 on 2024-03-23 21:48

from django.db import migrations, models


class Migration(migrations.Migration):
    dependencies = [
        ("bookmarks", "0026_userprofile_custom_css"),
    ]

    operations = [
        migrations.AddField(
            model_name="userprofile",
            name="bookmark_description_display",
            field=models.CharField(
                choices=[("inline", "Inline"), ("separate", "Separate")],
                default="inline",
                max_length=10,
            ),
        ),
        migrations.AddField(
            model_name="userprofile",
            name="bookmark_description_max_lines",
            field=models.IntegerField(default=1),
        ),
    ]


================================================
FILE: bookmarks/migrations/0028_userprofile_display_archive_bookmark_action_and_more.py
================================================
# Generated by Django 5.0.2 on 2024-03-29 20:05

from django.db import migrations, models


class Migration(migrations.Migration):
    dependencies = [
        ("bookmarks", "0027_userprofile_bookmark_description_display_and_more"),
    ]

    operations = [
        migrations.AddField(
            model_name="userprofile",
            name="display_archive_bookmark_action",
            field=models.BooleanField(default=True),
        ),
        migrations.AddField(
            model_name="userprofile",
            name="display_edit_bookmark_action",
            field=models.BooleanField(default=True),
        ),
        migrations.AddField(
            model_name="userprofile",
            name="display_remove_bookmark_action",
            field=models.BooleanField(default=True),
        ),
        migrations.AddField(
            model_name="userprofile",
            name="display_view_bookmark_action",
            field=models.BooleanField(default=True),
        ),
    ]


================================================
FILE: bookmarks/migrations/0029_bookmark_list_actions_toast.py
================================================
# Generated by Django 5.0.2 on 2024-03-29 21:25

from django.contrib.auth import get_user_model
from django.db import migrations

from bookmarks.models import Toast

User = get_user_model()


def forwards(apps, schema_editor):
    for user in User.objects.all():
        toast = Toast(
            key="bookmark_list_actions_hint",
            message="This version adds a new link to each bookmark to view details in a dialog. If you feel there is too much clutter you can now hide individual links in the settings.",
            owner=user,
        )
        toast.save()


def reverse(apps, schema_editor):
    Toast.objects.filter(key="bookmark_list_actions_hint").delete()


class Migration(migrations.Migration):
    dependencies = [
        ("bookmarks", "0028_userprofile_display_archive_bookmark_action_and_more"),
    ]

    operations = [
        migrations.RunPython(forwards, reverse),
    ]


================================================
FILE: bookmarks/migrations/0030_bookmarkasset.py
================================================
# Generated by Django 5.0.2 on 2024-03-31 08:21

import django.db.models.deletion
from django.db import migrations, models


class Migration(migrations.Migration):
    dependencies = [
        ("bookmarks", "0029_bookmark_list_actions_toast"),
    ]

    operations = [
        migrations.CreateModel(
            name="BookmarkAsset",
            fields=[
                (
                    "id",
                    models.AutoField(
                        auto_created=True,
                        primary_key=True,
                        serialize=False,
                        verbose_name="ID",
                    ),
                ),
                ("date_created", models.DateTimeField(auto_now_add=True)),
                ("file", models.CharField(blank=True, max_length=2048)),
                ("file_size", models.IntegerField(null=True)),
                ("asset_type", models.CharField(max_length=64)),
                ("content_type", models.CharField(max_length=128)),
                ("display_name", models.CharField(blank=True, max_length=2048)),
                ("status", models.CharField(max_length=64)),
                ("gzip", models.BooleanField(default=False)),
                (
                    "bookmark",
                    models.ForeignKey(
                        on_delete=django.db.models.deletion.CASCADE,
                        to="bookmarks.bookmark",
                    ),
                ),
            ],
        ),
    ]


================================================
FILE: bookmarks/migrations/0031_userprofile_enable_automatic_html_snapshots.py
================================================
# Generated by Django 5.0.2 on 2024-04-01 10:29

from django.db import migrations, models


class Migration(migrations.Migration):
    dependencies = [
        ("bookmarks", "0030_bookmarkasset"),
    ]

    operations = [
        migrations.AddField(
            model_name="userprofile",
            name="enable_automatic_html_snapshots",
            field=models.BooleanField(default=True),
        ),
    ]


================================================
FILE: bookmarks/migrations/0032_html_snapshots_hint_toast.py
================================================
# Generated by Django 5.0.2 on 2024-04-01 12:17

from django.contrib.auth import get_user_model
from django.db import migrations

from bookmarks.models import Toast

User = get_user_model()


def forwards(apps, schema_editor):
    for user in User.objects.all():
        toast = Toast(
            key="html_snapshots_hint",
            message="This version adds a new feature for archiving snapshots of websites locally. To use it, you need to switch to a different Docker image. See the installation instructions on GitHub for details.",
            owner=user,
        )
        toast.save()


def reverse(apps, schema_editor):
    Toast.objects.filter(key="bookmark_list_actions_hint").delete()


class Migration(migrations.Migration):
    dependencies = [
        ("bookmarks", "0031_userprofile_enable_automatic_html_snapshots"),
    ]

    operations = [
        migrations.RunPython(forwards, reverse),
    ]


================================================
FILE: bookmarks/migrations/0033_userprofile_default_mark_unread.py
================================================
# Generated by Django 5.0.3 on 2024-04-17 19:27

from django.db import migrations, models


class Migration(migrations.Migration):
    dependencies = [
        ("bookmarks", "0032_html_snapshots_hint_toast"),
    ]

    operations = [
        migrations.AddField(
            model_name="userprofile",
            name="default_mark_unread",
            field=models.BooleanField(default=False),
        ),
    ]


================================================
FILE: bookmarks/migrations/0034_bookmark_preview_image_file_and_more.py
================================================
# Generated by Django 5.0.3 on 2024-05-10 07:01

from django.db import migrations, models


class Migration(migrations.Migration):
    dependencies = [
        ("bookmarks", "0033_userprofile_default_mark_unread"),
    ]

    operations = [
        migrations.AddField(
            model_name="bookmark",
            name="preview_image_file",
            field=models.CharField(blank=True, max_length=512),
        ),
        migrations.AddField(
            model_name="userprofile",
            name="enable_preview_images",
            field=models.BooleanField(default=False),
        ),
    ]


================================================
FILE: bookmarks/migrations/0035_userprofile_tag_grouping.py
================================================
# Generated by Django 5.0.3 on 2024-05-14 08:28

from django.db import migrations, models


class Migration(migrations.Migration):
    dependencies = [
        ("bookmarks", "0034_bookmark_preview_image_file_and_more"),
    ]

    operations = [
        migrations.AddField(
            model_name="userprofile",
            name="tag_grouping",
            field=models.CharField(
                choices=[("alphabetical", "Alphabetical"), ("disabled", "Disabled")],
                default="alphabetical",
                max_length=12,
            ),
        ),
    ]


================================================
FILE: bookmarks/migrations/0036_userprofile_auto_tagging_rules.py
================================================
# Generated by Django 5.0.3 on 2024-05-17 07:09

from django.db import migrations, models


class Migration(migrations.Migration):
    dependencies = [
        ("bookmarks", "0035_userprofile_tag_grouping"),
    ]

    operations = [
        migrations.AddField(
            model_name="userprofile",
            name="auto_tagging_rules",
            field=models.TextField(blank=True),
        ),
    ]


================================================
FILE: bookmarks/migrations/0037_globalsettings.py
================================================
# Generated by Django 5.0.8 on 2024-08-31 12:39

from django.db import migrations, models


class Migration(migrations.Migration):
    dependencies = [
        ("bookmarks", "0036_userprofile_auto_tagging_rules"),
    ]

    operations = [
        migrations.CreateModel(
            name="GlobalSettings",
            fields=[
                (
                    "id",
                    models.AutoField(
                        auto_created=True,
                        primary_key=True,
                        serialize=False,
                        verbose_name="ID",
                    ),
                ),
                (
                    "landing_page",
                    models.CharField(
                        choices=[
                            ("login", "Login"),
                            ("shared_bookmarks", "Shared Bookmarks"),
                        ],
                        default="login",
                        max_length=50,
                    ),
                ),
            ],
        ),
    ]


================================================
FILE: bookmarks/migrations/0038_globalsettings_guest_profile_user.py
================================================
# Generated by Django 5.0.8 on 2024-08-31 17:54

import django.db.models.deletion
from django.conf import settings
from django.db import migrations, models


class Migration(migrations.Migration):
    dependencies = [
        ("bookmarks", "0037_globalsettings"),
        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
    ]

    operations = [
        migrations.AddField(
            model_name="globalsettings",
            name="guest_profile_user",
            field=models.ForeignKey(
                blank=True,
                null=True,
                on_delete=django.db.models.deletion.SET_NULL,
                to=settings.AUTH_USER_MODEL,
            ),
        ),
    ]


================================================
FILE: bookmarks/migrations/0039_globalsettings_enable_link_prefetch.py
================================================
# Generated by Django 5.0.8 on 2024-09-14 07:48

from django.db import migrations, models


class Migration(migrations.Migration):
    dependencies = [
        ("bookmarks", "0038_globalsettings_guest_profile_user"),
    ]

    operations = [
        migrations.AddField(
            model_name="globalsettings",
            name="enable_link_prefetch",
            field=models.BooleanField(default=False),
        ),
    ]


================================================
FILE: bookmarks/migrations/0040_userprofile_items_per_page_and_more.py
================================================
# Generated by Django 5.0.8 on 2024-09-18 20:11

import django.core.validators
from django.db import migrations, models


class Migration(migrations.Migration):
    dependencies = [
        ("bookmarks", "0039_globalsettings_enable_link_prefetch"),
    ]

    operations = [
        migrations.AddField(
            model_name="userprofile",
            name="items_per_page",
            field=models.IntegerField(
                default=30, validators=[django.core.validators.MinValueValidator(10)]
            ),
        ),
        migrations.AddField(
            model_name="userprofile",
            name="sticky_pagination",
            field=models.BooleanField(default=False),
        ),
    ]


================================================
FILE: bookmarks/migrations/0041_merge_metadata.py
================================================
# Generated by Django 5.1.1 on 2024-09-21 08:13

from django.db import migrations
from django.db.models import Q
from django.db.models.expressions import RawSQL

from bookmarks.models import Bookmark


def forwards(apps, schema_editor):
    Bookmark.objects.filter(
        Q(title__isnull=True) | Q(title__exact=""),
    ).extra(where=["website_title IS NOT NULL"]).update(
        title=RawSQL("website_title", ())
    )

    Bookmark.objects.filter(
        Q(description__isnull=True) | Q(description__exact=""),
    ).extra(where=["website_description IS NOT NULL"]).update(
        description=RawSQL("website_description", ())
    )


def reverse(apps, schema_editor):
    pass


class Migration(migrations.Migration):
    dependencies = [
        ("bookmarks", "0040_userprofile_items_per_page_and_more"),
    ]

    operations = [
        migrations.RunPython(forwards, reverse),
    ]


================================================
FILE: bookmarks/migrations/0042_userprofile_custom_css_hash.py
================================================
# Generated by Django 5.1.1 on 2024-09-28 08:03

from django.db import migrations, models


class Migration(migrations.Migration):
    dependencies = [
        ("bookmarks", "0041_merge_metadata"),
    ]

    operations = [
        migrations.AddField(
            model_name="userprofile",
            name="custom_css_hash",
            field=models.CharField(blank=True, max_length=32),
        ),
    ]


================================================
FILE: bookmarks/migrations/0043_userprofile_collapse_side_panel.py
================================================
# Generated by Django 5.1.5 on 2025-02-02 09:35

from django.db import migrations, models


class Migration(migrations.Migration):
    dependencies = [
        ("bookmarks", "0042_userprofile_custom_css_hash"),
    ]

    operations = [
        migrations.AddField(
            model_name="userprofile",
            name="collapse_side_panel",
            field=models.BooleanField(default=False),
        ),
    ]


================================================
FILE: bookmarks/migrations/0044_bookmark_latest_snapshot.py
================================================
# Generated by Django 5.1.7 on 2025-03-22 12:28

import django.db.models.deletion
from django.db import migrations, models
from django.db.models import OuterRef, Subquery


def forwards(apps, schema_editor):
    # Update the latest snapshot for each bookmark
    Bookmark = apps.get_model("bookmarks", "bookmark")
    BookmarkAsset = apps.get_model("bookmarks", "bookmarkasset")

    latest_snapshots = (
        BookmarkAsset.objects.filter(
            bookmark=OuterRef("pk"), asset_type="snapshot", status="complete"
        )
        .order_by("-date_created")
        .values("id")[:1]
    )
    Bookmark.objects.update(latest_snapshot_id=Subquery(latest_snapshots))


def reverse(apps, schema_editor):
    pass


class Migration(migrations.Migration):
    dependencies = [
        ("bookmarks", "0043_userprofile_collapse_side_panel"),
    ]

    operations = [
        migrations.AddField(
            model_name="bookmark",
            name="latest_snapshot",
            field=models.ForeignKey(
                blank=True,
                null=True,
                on_delete=django.db.models.deletion.SET_NULL,
                related_name="latest_snapshot",
                to="bookmarks.bookmarkasset",
            ),
        ),
        migrations.RunPython(forwards, reverse),
    ]


================================================
FILE: bookmarks/migrations/0045_userprofile_hide_bundles_bookmarkbundle.py
================================================
# Generated by Django 5.1.9 on 2025-06-19 08:48

import django.db.models.deletion
from django.conf import settings
from django.db import migrations, models


class Migration(migrations.Migration):
    dependencies = [
        ("bookmarks", "0044_bookmark_latest_snapshot"),
        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
    ]

    operations = [
        migrations.AddField(
            model_name="userprofile",
            name="hide_bundles",
            field=models.BooleanField(default=False),
        ),
        migrations.CreateModel(
            name="BookmarkBundle",
            fields=[
                (
                    "id",
                    models.AutoField(
                        auto_created=True,
                        primary_key=True,
                        serialize=False,
                        verbose_name="ID",
                    ),
                ),
                ("name", models.CharField(max_length=256)),
                ("search", models.CharField(blank=True, max_length=256)),
                ("any_tags", models.CharField(blank=True, max_length=1024)),
                ("all_tags", models.CharField(blank=True, max_length=1024)),
                ("excluded_tags", models.CharField(blank=True, max_length=1024)),
                ("order", models.IntegerField(default=0)),
                ("date_created", models.DateTimeField(auto_now_add=True)),
                ("date_modified", models.DateTimeField(auto_now=True)),
                (
                    "owner",
                    models.ForeignKey(
                        on_delete=django.db.models.deletion.CASCADE,
                        to=settings.AUTH_USER_MODEL,
                    ),
                ),
            ],
        ),
    ]


================================================
FILE: bookmarks/migrations/0046_add_url_normalized_field.py
================================================
# Generated by Django 5.2.3 on 2025-08-22 08:26

from django.db import migrations, models


class Migration(migrations.Migration):
    dependencies = [
        ("bookmarks", "0045_userprofile_hide_bundles_bookmarkbundle"),
    ]

    operations = [
        migrations.AddField(
            model_name="bookmark",
            name="url_normalized",
            field=models.CharField(blank=True, db_index=True, max_length=2048),
        ),
    ]


================================================
FILE: bookmarks/migrations/0047_populate_url_normalized_field.py
================================================
# Generated by Django 5.2.3 on 2025-08-22 08:28

from django.db import migrations, transaction

from bookmarks.utils import normalize_url


def populate_url_normalized(apps, schema_editor):
    Bookmark = apps.get_model("bookmarks", "Bookmark")

    batch_size = 500
    with transaction.atomic():
        qs = Bookmark.objects.all()
        for start in range(0, qs.count(), batch_size):
            batch = list(qs[start : start + batch_size])
            for bookmark in batch:
                bookmark.url_normalized = normalize_url(bookmark.url)
            Bookmark.objects.bulk_update(
                batch, ["url_normalized"], batch_size=batch_size
            )


def reverse_populate_url_normalized(apps, schema_editor):
    Bookmark = apps.get_model("bookmarks", "Bookmark")
    Bookmark.objects.all().update(url_normalized="")


class Migration(migrations.Migration):
    dependencies = [
        ("bookmarks", "0046_add_url_normalized_field"),
    ]

    operations = [
        migrations.RunPython(
            populate_url_normalized,
            reverse_populate_url_normalized,
        ),
    ]


================================================
FILE: bookmarks/migrations/0048_userprofile_default_mark_shared.py
================================================
# Generated by Django 5.2.3 on 2025-08-22 17:38

from django.db import migrations, models


class Migration(migrations.Migration):
    dependencies = [
        ("bookmarks", "0047_populate_url_normalized_field"),
    ]

    operations = [
        migrations.AddField(
            model_name="userprofile",
            name="default_mark_shared",
            field=models.BooleanField(default=False),
        ),
    ]


================================================
FILE: bookmarks/migrations/0049_userprofile_legacy_search.py
================================================
# Generated by Django 5.2.5 on 2025-10-05 09:10

from django.db import migrations, models


class Migration(migrations.Migration):
    dependencies = [
        ("bookmarks", "0048_userprofile_default_mark_shared"),
    ]

    operations = [
        migrations.AddField(
            model_name="userprofile",
            name="legacy_search",
            field=models.BooleanField(default=False),
        ),
    ]


================================================
FILE: bookmarks/migrations/0050_new_search_toast.py
================================================
# Generated by Django 5.2.5 on 2025-10-05 10:01

from django.contrib.auth import get_user_model
from django.db import migrations

from bookmarks.models import Toast

User = get_user_model()


def forwards(apps, schema_editor):
    for user in User.objects.all():
        toast = Toast(
            key="new_search_toast",
            message="This version replaces the search engine with a new implementation that supports logical operators (and, or, not). If you run into any issues with the new search, you can switch back to the old one by enabling legacy search in the settings.",
            owner=user,
        )
        toast.save()


def reverse(apps, schema_editor):
    Toast.objects.filter(key="new_search_toast").delete()


class Migration(migrations.Migration):
    dependencies = [
        ("bookmarks", "0049_userprofile_legacy_search"),
    ]

    operations = [
        migrations.RunPython(forwards, reverse),
    ]


================================================
FILE: bookmarks/migrations/0051_fix_normalized_url.py
================================================
# Generated by Django 5.2.5 on 2025-10-11 08:46

from django.db import migrations

from bookmarks.utils import normalize_url


def fix_url_normalized(apps, schema_editor):
    Bookmark = apps.get_model("bookmarks", "Bookmark")

    batch_size = 200
    qs = Bookmark.objects.filter(url_normalized="").all()
    for start in range(0, qs.count(), batch_size):
        batch = list(qs[start : start + batch_size])
        for bookmark in batch:
            bookmark.url_normalized = normalize_url(bookmark.url)
        Bookmark.objects.bulk_update(batch, ["url_normalized"])


def reverse_fix_url_normalized(apps, schema_editor):
    pass


class Migration(migrations.Migration):
    dependencies = [
        ("bookmarks", "0050_new_search_toast"),
    ]

    operations = [
        migrations.RunPython(
            fix_url_normalized,
            reverse_fix_url_normalized,
        ),
    ]


================================================
FILE: bookmarks/migrations/0052_apitoken.py
================================================
# Generated by Django 5.2.5 on 2025-12-14 16:33

import django.db.models.deletion
from django.conf import settings
from django.db import migrations, models


class Migration(migrations.Migration):
    dependencies = [
        ("bookmarks", "0051_fix_normalized_url"),
        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
    ]

    operations = [
        migrations.CreateModel(
            name="ApiToken",
            fields=[
                (
                    "id",
                    models.AutoField(
                        auto_created=True,
                        primary_key=True,
                        serialize=False,
                        verbose_name="ID",
                    ),
                ),
                ("key", models.CharField(max_length=40, unique=True)),
                ("name", models.CharField(max_length=128)),
                ("created", models.DateTimeField(auto_now_add=True)),
                (
                    "user",
                    models.ForeignKey(
                        on_delete=django.db.models.deletion.CASCADE,
                        related_name="api_tokens",
                        to=settings.AUTH_USER_MODEL,
                    ),
                ),
            ],
        ),
    ]


================================================
FILE: bookmarks/migrations/0053_migrate_api_tokens.py
================================================
# Generated by Django 5.2.5 on 2025-12-14 16:34
from django.db import migrations


def migrate_tokens_forward(apps, schema_editor):
    Token = apps.get_model("authtoken", "Token")
    ApiToken = apps.get_model("bookmarks", "ApiToken")

    for old_token in Token.objects.all():
        ApiToken.objects.create(
            key=old_token.key,
            user=old_token.user,
            name="Default Token",
            created=old_token.created,
        )


def migrate_tokens_reverse(apps, schema_editor):
    ApiToken = apps.get_model("bookmarks", "ApiToken")
    ApiToken.objects.filter(name="Default Token").delete()


class Migration(migrations.Migration):
    dependencies = [
        ("bookmarks", "0052_apitoken"),
        ("authtoken", "0004_alter_tokenproxy_options"),
    ]

    operations = [
        migrations.RunPython(migrate_tokens_forward, migrate_tokens_reverse),
    ]


================================================
FILE: bookmarks/migrations/0054_bookmarkbundle_filter_shared_and_more.py
================================================
# Generated by Django 6.0 on 2026-02-28 09:05

from django.db import migrations, models


class Migration(migrations.Migration):
    dependencies = [
        ("bookmarks", "0053_migrate_api_tokens"),
    ]

    operations = [
        migrations.AddField(
            model_name="bookmarkbundle",
            name="filter_shared",
            field=models.CharField(
                choices=[("off", "All"), ("yes", "Shared"), ("no", "Unshared")],
                default="off",
                max_length=3,
            ),
        ),
        migrations.AddField(
            model_name="bookmarkbundle",
            name="filter_unread",
            field=models.CharField(
                choices=[("off", "All"), ("yes", "Unread"), ("no", "Read")],
                default="off",
                max_length=3,
            ),
        ),
    ]


================================================
FILE: bookmarks/migrations/__init__.py
================================================


================================================
FILE: bookmarks/models.py
================================================
import binascii
import hashlib
import logging
import os

from django.conf import settings
from django.contrib.auth.models import User
from django.core.validators import MinValueValidator
from django.db import models
from django.db.models import Q
from django.db.models.signals import post_delete, post_save
from django.dispatch import receiver
from django.http import QueryDict

from bookmarks.utils import normalize_url, unique
from bookmarks.validators import BookmarkURLValidator

logger = logging.getLogger(__name__)


class Tag(models.Model):
    name = models.CharField(max_length=64)
    date_added = models.DateTimeField()
    owner = models.ForeignKey(User, on_delete=models.CASCADE)

    def __str__(self):
        return self.name


def sanitize_tag_name(tag_name: str):
    # strip leading/trailing spaces
    # replace inner spaces with replacement char
    return tag_name.strip().replace(" ", "-")


def parse_tag_string(tag_string: str, delimiter: str = ","):
    if not tag_string:
        return []
    names = tag_string.strip().split(delimiter)
    # remove empty names, sanitize remaining names
    names = [sanitize_tag_name(name) for name in names if name.strip()]
    # remove duplicates
    names = unique(names, str.lower)
    names.sort(key=str.lower)

    return names


def build_tag_string(tag_names: list[str], delimiter: str = ","):
    return delimiter.join(tag_names)


class Bookmark(models.Model):
    url = models.CharField(max_length=2048, validators=[BookmarkURLValidator()])
    url_normalized = models.CharField(max_length=2048, blank=True, db_index=True)
    title = models.CharField(max_length=512, blank=True)
    description = models.TextField(blank=True)
    notes = models.TextField(blank=True)
    # Obsolete field, kept to not remove column when generating migrations
    website_title = models.CharField(max_length=512, blank=True, null=True)
    # Obsolete field, kept to not remove column when generating migrations
    website_description = models.TextField(blank=True, null=True)
    web_archive_snapshot_url = models.CharField(max_length=2048, blank=True)
    favicon_file = models.CharField(max_length=512, blank=True)
    preview_image_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(User, on_delete=models.CASCADE)
    tags = models.ManyToManyField(Tag)
    latest_snapshot = models.ForeignKey(
        "BookmarkAsset",
        on_delete=models.SET_NULL,
        null=True,
        blank=True,
        related_name="latest_snapshot",
    )

    @property
    def resolved_title(self):
        if self.title:
            return self.title
        else:
            return self.url

    @property
    def resolved_description(self):
        return self.description

    @property
    def tag_names(self):
        names = [tag.name for tag in self.tags.all()]
        return sorted(names)

    def save(self, *args, **kwargs):
        self.url_normalized = normalize_url(self.url)
        super().save(*args, **kwargs)

    def __str__(self):
        return self.resolved_title + " (" + self.url[:30] + "...)"

    @staticmethod
    def query_existing(owner: User, url: str) -> models.QuerySet:
        # Find existing bookmark by normalized URL, or fall back to exact URL if
        # normalized URL was not generated for whatever reason
        normalized_url = normalize_url(url)
        q = Q(owner=owner) & (
            Q(url_normalized=normalized_url) | Q(url_normalized="", url=url)
        )
        return Bookmark.objects.filter(q)


@receiver(post_delete, sender=Bookmark)
def bookmark_deleted(sender, instance, **kwargs):
    if instance.preview_image_file:
        filepath = os.path.join(settings.LD_PREVIEW_FOLDER, instance.preview_image_file)
        if os.path.isfile(filepath):
            try:
                os.remove(filepath)
            except Exception as error:
                logger.error(
                    f"Failed to delete preview image: {filepath}", exc_info=error
                )


class BookmarkAsset(models.Model):
    TYPE_SNAPSHOT = "snapshot"
    TYPE_UPLOAD = "upload"

    CONTENT_TYPE_HTML = "text/html"
    CONTENT_TYPE_PDF = "application/pdf"

    STATUS_PENDING = "pending"
    STATUS_COMPLETE = "complete"
    STATUS_FAILURE = "failure"

    bookmark = models.ForeignKey(Bookmark, on_delete=models.CASCADE)
    date_created = models.DateTimeField(auto_now_add=True, null=False)
    file = models.CharField(max_length=2048, blank=True, null=False)
    file_size = models.IntegerField(null=True)
    asset_type = models.CharField(max_length=64, blank=False, null=False)
    content_type = models.CharField(max_length=128, blank=False, null=False)
    display_name = models.CharField(max_length=2048, blank=True, null=False)
    status = models.CharField(max_length=64, blank=False, null=False)
    gzip = models.BooleanField(default=False, null=False)

    @property
    def download_name(self):
        if self.asset_type == BookmarkAsset.TYPE_SNAPSHOT:
            if self.content_type == BookmarkAsset.CONTENT_TYPE_PDF:
                return f"{self.display_name}.pdf"
            return f"{self.display_name}.html"
        return self.display_name

    def save(self, *args, **kwargs):
        if self.file:
            try:
                file_path = os.path.join(settings.LD_ASSET_FOLDER, self.file)
                if os.path.isfile(file_path):
                    self.file_size = os.path.getsize(file_path)
            except Exception:
                pass
        super().save(*args, **kwargs)

    def __str__(self):
        return self.display_name or f"Bookmark Asset #{self.pk}"


@receiver(post_delete, sender=BookmarkAsset)
def bookmark_asset_deleted(sender, instance, **kwargs):
    if instance.file:
        filepath = os.path.join(settings.LD_ASSET_FOLDER, instance.file)
        if os.path.isfile(filepath):
            try:
                os.remove(filepath)
            except Exception as error:
                logger.error(f"Failed to delete asset file: {filepath}", exc_info=error)


class BookmarkBundle(models.Model):
    FILTER_STATE_OFF = "off"
    FILTER_STATE_YES = "yes"
    FILTER_STATE_NO = "no"
    FILTER_UNREAD_CHOICES = [
        (FILTER_STATE_OFF, "All"),
        (FILTER_STATE_YES, "Unread"),
        (FILTER_STATE_NO, "Read"),
    ]
    FILTER_SHARED_CHOICES = [
        (FILTER_STATE_OFF, "All"),
        (FILTER_STATE_YES, "Shared"),
        (FILTER_STATE_NO, "Unshared"),
    ]

    name = models.CharField(max_length=256, blank=False)
    search = models.CharField(max_length=256, blank=True)
    any_tags = models.CharField(max_length=1024, blank=True)
    all_tags = models.CharField(max_length=1024, blank=True)
    excluded_tags = models.CharField(max_length=1024, blank=True)
    filter_unread = models.CharField(
        max_length=3,
        choices=FILTER_UNREAD_CHOICES,
        blank=False,
        default=FILTER_STATE_OFF,
    )
    filter_shared = models.CharField(
        max_length=3,
        choices=FILTER_SHARED_CHOICES,
        blank=False,
        default=FILTER_STATE_OFF,
    )
    order = models.IntegerField(null=False, default=0)
    date_created = models.DateTimeField(auto_now_add=True, null=False)
    date_modified = models.DateTimeField(auto_now=True, null=False)
    owner = models.ForeignKey(User, on_delete=models.CASCADE)

    def __str__(self):
        return self.name


class BookmarkSearch:
    SORT_ADDED_ASC = "added_asc"
    SORT_ADDED_DESC = "added_desc"
    SORT_TITLE_ASC = "title_asc"
    SORT_TITLE_DESC = "title_desc"

    FILTER_SHARED_OFF = "off"
    FILTER_SHARED_SHARED = "yes"
    FILTER_SHARED_UNSHARED = "no"

    FILTER_UNREAD_OFF = "off"
    FILTER_UNREAD_YES = "yes"
    FILTER_UNREAD_NO = "no"

    params = [
        "q",
        "user",
        "bundle",
        "sort",
        "shared",
        "unread",
        "modified_since",
        "added_since",
    ]
    preferences = ["sort", "shared", "unread"]
    defaults = {
        "q": "",
        "user": "",
        "bundle": None,
        "sort": SORT_ADDED_DESC,
        "shared": FILTER_SHARED_OFF,
        "unread": FILTER_UNREAD_OFF,
        "modified_since": None,
        "added_since": None,
    }

    def __init__(
        self,
        q: str = None,
        user: str = None,
        bundle: BookmarkBundle = None,
        sort: str = None,
        shared: str = None,
        unread: str = None,
        modified_since: str = None,
        added_since: str = None,
        preferences: dict = None,
        request: any = None,
    ):
        if not preferences:
            preferences = {}
        self.defaults = {**BookmarkSearch.defaults, **preferences}
        self.request = request

        self.q = q or self.defaults["q"]
        self.user = user or self.defaults["user"]
        self.bundle = bundle or self.defaults["bundle"]
        self.sort = sort or self.defaults["sort"]
        self.shared = shared or self.defaults["shared"]
        self.unread = unread or self.defaults["unread"]
        self.modified_since = modified_since or self.defaults["modified_since"]
        self.added_since = added_since or self.defaults["added_since"]

    def is_modified(self, param):
        value = self.__dict__[param]
        return value != self.defaults[param]

    @property
    def modified_params(self):
        return [field for field in self.params if self.is_modified(field)]

    @property
    def modified_preferences(self):
        return [
            preference
            for preference in self.preferences
            if self.is_modified(preference)
        ]

    @property
    def has_modifications(self):
        return len(self.modified_params) > 0

    @property
    def has_modified_preferences(self):
        return len(self.modified_preferences) > 0

    @property
    def query_params(self):
        query_params = {}
        for param in self.modified_params:
            value = self.__dict__[param]
            if isinstance(value, models.Model):
                query_params[param] = value.id
            else:
                query_params[param] = value
        return query_params

    @property
    def preferences_dict(self):
        return {
            preference: self.__dict__[preference] for preference in self.preferences
        }

    @staticmethod
    def from_request(request: any, query_dict: QueryDict, preferences: dict = None):
        initial_values = {}
        for param in BookmarkSearch.params:
            value = query_dict.get(param)
            if value:
                if param == "bundle":
                    initial_values[param] = BookmarkBundle.objects.filter(
                        owner=request.user, pk=value
                    ).first()
                else:
                    initial_values[param] = value

        return BookmarkSearch(
            **initial_values, preferences=preferences, request=request
        )


class UserProfile(models.Model):
    THEME_AUTO = "auto"
    THEME_LIGHT = "light"
    THEME_DARK = "dark"
    THEME_CHOICES = [
        (THEME_AUTO, "Auto"),
        (THEME_LIGHT, "Light"),
        (THEME_DARK, "Dark"),
    ]
    BOOKMARK_DATE_DISPLAY_RELATIVE = "relative"
    BOOKMARK_DATE_DISPLAY_ABSOLUTE = "absolute"
    BOOKMARK_DATE_DISPLAY_HIDDEN = "hidden"
    BOOKMARK_DATE_DISPLAY_CHOICES = [
        (BOOKMARK_DATE_DISPLAY_RELATIVE, "Relative"),
        (BOOKMARK_DATE_DISPLAY_ABSOLUTE, "Absolute"),
        (BOOKMARK_DATE_DISPLAY_HIDDEN, "Hidden"),
    ]
    BOOKMARK_DESCRIPTION_DISPLAY_INLINE = "inline"
    BOOKMARK_DESCRIPTION_DISPLAY_SEPARATE = "separate"
    BOOKMARK_DESCRIPTION_DISPLAY_CHOICES = [
        (BOOKMARK_DESCRIPTION_DISPLAY_INLINE, "Inline"),
        (BOOKMARK_DESCRIPTION_DISPLAY_SEPARATE, "Separate"),
    ]
    BOOKMARK_LINK_TARGET_BLANK = "_blank"
    BOOKMARK_LINK_TARGET_SELF = "_self"
    BOOKMARK_LINK_TARGET_CHOICES = [
        (BOOKMARK_LINK_TARGET_BLANK, "New page"),
        (BOOKMARK_LINK_TARGET_SELF, "Same page"),
    ]
    WEB_ARCHIVE_INTEGRATION_DISABLED = "disabled"
    WEB_ARCHIVE_INTEGRATION_ENABLED = "enabled"
    WEB_ARCHIVE_INTEGRATION_CHOICES = [
        (WEB_ARCHIVE_INTEGRATION_DISABLED, "Disabled"),
        (WEB_ARCHIVE_INTEGRATION_ENABLED, "Enabled"),
    ]
    TAG_SEARCH_STRICT = "strict"
    TAG_SEARCH_LAX = "lax"
    TAG_SEARCH_CHOICES = [
        (TAG_SEARCH_STRICT, "Strict"),
        (TAG_SEARCH_LAX, "Lax"),
    ]
    TAG_GROUPING_ALPHABETICAL = "alphabetical"
    TAG_GROUPING_DISABLED = "disabled"
    TAG_GROUPING_CHOICES = [
        (TAG_GROUPING_ALPHABETICAL, "Alphabetical"),
        (TAG_GROUPING_DISABLED, "Disabled"),
    ]
    user = models.OneToOneField(User, related_name="profile", on_delete=models.CASCADE)
    theme = models.CharField(
        max_length=10, choices=THEME_CHOICES, blank=False, default=THEME_AUTO
    )
    bookmark_date_display = models.CharField(
        max_length=10,
        choices=BOOKMARK_DATE_DISPLAY_CHOICES,
        blank=False,
        default=BOOKMARK_DATE_DISPLAY_RELATIVE,
    )
    bookmark_description_display = models.CharField(
        max_length=10,
        choices=BOOKMARK_DESCRIPTION_DISPLAY_CHOICES,
        blank=False,
        default=BOOKMARK_DESCRIPTION_DISPLAY_INLINE,
    )
    bookmark_description_max_lines = models.IntegerField(
        null=False,
        default=1,
    )
    bookmark_link_target = models.CharField(
        max_length=10,
        choices=BOOKMARK_LINK_TARGET_CHOICES,
        blank=False,
        default=BOOKMARK_LINK_TARGET_BLANK,
    )
    web_archive_integration = models.CharField(
        max_length=10,
        choices=WEB_ARCHIVE_INTEGRATION_CHOICES,
        blank=False,
        default=WEB_ARCHIVE_INTEGRATION_DISABLED,
    )
    tag_search = models.CharField(
        max_length=10,
        choices=TAG_SEARCH_CHOICES,
        blank=False,
        default=TAG_SEARCH_STRICT,
    )
    tag_grouping = models.CharField(
        max_length=12,
        choices=TAG_GROUPING_CHOICES,
        blank=False,
        default=TAG_GROUPING_ALPHABETICAL,
    )
    enable_sharing = models.BooleanField(default=False, null=False)
    enable_public_sharing = models.BooleanField(default=False, null=False)
    enable_favicons = models.BooleanField(default=False, null=False)
    enable_preview_images = models.BooleanField(default=False, null=False)
    display_url = models.BooleanField(default=False, null=False)
    display_view_bookmark_action = models.BooleanField(default=True, null=False)
    display_edit_bookmark_action = models.BooleanField(default=True, null=False)
    display_archive_bookmark_action = models.BooleanField(default=True, null=False)
    display_remove_bookmark_action = models.BooleanField(default=True, null=False)
    permanent_notes = models.BooleanField(default=False, null=False)
    custom_css = models.TextField(blank=True, null=False)
    custom_css_hash = models.CharField(blank=True, null=False, max_length=32)
    auto_tagging_rules = models.TextField(blank=True, null=False)
    search_preferences = models.JSONField(default=dict, null=False)
    enable_automatic_html_snapshots = models.BooleanField(default=True, null=False)
    default_mark_unread = models.BooleanField(default=False, null=False)
    default_mark_shared = models.BooleanField(default=False, null=False)
    items_per_page = models.IntegerField(
        null=False, default=30, validators=[MinValueValidator(10)]
    )
    sticky_pagination = models.BooleanField(default=False, null=False)
    collapse_side_panel = models.BooleanField(default=False, null=False)
    hide_bundles = models.BooleanField(default=False, null=False)
    legacy_search = models.BooleanField(default=False, null=False)

    def save(self, *args, **kwargs):
        if self.custom_css:
            self.custom_css_hash = hashlib.md5(
                self.custom_css.encode("utf-8")
            ).hexdigest()
        else:
            self.custom_css_hash = ""
        super().save(*args, **kwargs)


@receiver(post_save, sender=User)
def create_user_profile(sender, instance, created, **kwargs):
    if created:
        UserProfile.objects.create(user=instance)


@receiver(post_save, sender=User)
def save_user_profile(sender, instance, **kwargs):
    instance.profile.save()


class Toast(models.Model):
    key = models.CharField(max_length=50)
    message = models.TextField()
    acknowledged = models.BooleanField(default=False)
    owner = models.ForeignKey(User, 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(
        User,
        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


class ApiToken(models.Model):
    key = models.CharField(max_length=40, unique=True)
    user = models.ForeignKey(
        User,
        related_name="api_tokens",
        on_delete=models.CASCADE,
    )
    name = models.CharField(max_length=128, blank=False)
    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 f"{self.name} ({self.user.username})"


class GlobalSettings(models.Model):
    LANDING_PAGE_LOGIN = "login"
    LANDING_PAGE_SHARED_BOOKMARKS = "shared_bookmarks"
    LANDING_PAGE_CHOICES = [
        (LANDING_PAGE_LOGIN, "Login"),
        (LANDING_PAGE_SHARED_BOOKMARKS, "Shared Bookmarks"),
    ]

    landing_page = models.CharField(
        max_length=50,
        choices=LANDING_PAGE_CHOICES,
        blank=False,
        default=LANDING_PAGE_LOGIN,
    )
    guest_profile_user = models.ForeignKey(
        User, on_delete=models.SET_NULL, null=True, blank=True
    )
    enable_link_prefetch = models.BooleanField(default=False, null=False)

    @classmethod
    def get(cls):
        instance = GlobalSettings.objects.first()
        if not instance:
            instance = GlobalSettings()
            instance.save()
        return instance

    def save(self, *args, **kwargs):
        if not self.pk and GlobalSettings.objects.exists():
            raise Exception("There is already one instance of GlobalSettings")
        return super().save(*args, **kwargs)


================================================
FILE: bookmarks/queries.py
================================================
import contextlib

from django.conf import settings
from django.contrib.auth.models import User
from django.core.exceptions import ValidationError
from django.db.models import Case, CharField, Exists, OuterRef, Q, QuerySet, When
from django.db.models.expressions import RawSQL
from django.db.models.functions import Lower

from bookmarks.models import (
    Bookmark,
    BookmarkBundle,
    BookmarkSearch,
    Tag,
    UserProfile,
    parse_tag_string,
)
from bookmarks.services.search_query_parser import (
    AndExpression,
    NotExpression,
    OrExpression,
    SearchExpression,
    SearchQueryParseError,
    SpecialKeywordExpression,
    TagExpression,
    TermExpression,
    extract_tag_names_from_query,
    parse_search_query,
)
from bookmarks.utils import unique


def query_bookmarks(
    user: User,
    profile: UserProfile,
    search: BookmarkSearch,
) -> QuerySet:
    return _base_bookmarks_query(user, profile, search).filter(is_archived=False)


def query_archived_bookmarks(
    user: User, profile: UserProfile, search: BookmarkSearch
) -> QuerySet:
    return _base_bookmarks_query(user, profile, search).filter(is_archived=True)


def query_shared_bookmarks(
    user: User | None,
    profile: UserProfile,
    search: BookmarkSearch,
    public_only: bool,
) -> QuerySet:
    conditions = Q(shared=True) & Q(owner__profile__enable_sharing=True)
    if public_only:
        conditions = conditions & Q(owner__profile__enable_public_sharing=True)

    return _base_bookmarks_query(user, profile, search).filter(conditions)


def _convert_ast_to_q_object(ast_node: SearchExpression, profile: UserProfile) -> Q:
    if isinstance(ast_node, TermExpression):
        # Search across title, description, notes, URL
        conditions = (
            Q(title__icontains=ast_node.term)
            | Q(description__icontains=ast_node.term)
            | Q(notes__icontains=ast_node.term)
            | Q(url__icontains=ast_node.term)
        )

        # In lax mode, also search in tag names
        if profile.tag_search == UserProfile.TAG_SEARCH_LAX:
            conditions = conditions | Exists(
                Bookmark.objects.filter(
                    id=OuterRef("id"), tags__name__iexact=ast_node.term
                )
            )

        return conditions

    elif isinstance(ast_node, TagExpression):
        # Use Exists() to avoid reusing the same join when combining multiple tag expressions with and
        return Q(
            Exists(
                Bookmark.objects.filter(
                    id=OuterRef("id"), tags__name__iexact=ast_node.tag
                )
            )
        )

    elif isinstance(ast_node, SpecialKeywordExpression):
        # Handle special keywords
        if ast_node.keyword.lower() == "unread":
            return Q(unread=True)
        elif ast_node.keyword.lower() == "untagged":
            return Q(tags=None)
        else:
            # Unknown keyword, return empty Q object (matches all)
            return Q()

    elif isinstance(ast_node, AndExpression):
        # Combine left and right with AND
        left_q = _convert_ast_to_q_object(ast_node.left, profile)
        right_q = _convert_ast_to_q_object(ast_node.right, profile)
        return left_q & right_q

    elif isinstance(ast_node, OrExpression):
        # Combine left and right with OR
        left_q = _convert_ast_to_q_object(ast_node.left, profile)
        right_q = _convert_ast_to_q_object(ast_node.right, profile)
        return left_q | right_q

    elif isinstance(ast_node, NotExpression):
        # Negate the operand
        operand_q = _convert_ast_to_q_object(ast_node.operand, profile)
        return ~operand_q

    else:
        # Fallback for unknown node types
        return Q()


def _filter_search_query(
    query_set: QuerySet, query_string: str, profile: UserProfile
) -> QuerySet:
    """New search filtering logic using logical expressions."""

    try:
        ast = parse_search_query(query_string)
        if ast:
            search_query = _convert_ast_to_q_object(ast, profile)
            query_set = query_set.filter(search_query)
    except SearchQueryParseError:
        # If the query cannot be parsed, return zero results
        return query_set.none()

    return query_set


def _filter_search_query_legacy(
    query_set: QuerySet, query_string: str, profile: UserProfile
) -> QuerySet:
    """Legacy search filtering logic where everything is just combined with AND."""

    # Split query into search terms and tags
    query = parse_query_string(query_string)

    # Filter for search terms and tags
    for term in query["search_terms"]:
        conditions = (
            Q(title__icontains=term)
            | Q(description__icontains=term)
            | Q(notes__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(tags__name__iexact=tag_name)

    # Untagged bookmarks
    if query["untagged"]:
        query_set = query_set.filter(tags=None)
    # Legacy unread bookmarks filter from query
    if query["unread"]:
        query_set = query_set.filter(unread=True)

    return query_set


def _filter_bundle(query_set: QuerySet, bundle: BookmarkBundle) -> QuerySet:
    # Search terms
    search_terms = parse_query_string(bundle.search)["search_terms"]
    for term in search_terms:
        conditions = (
            Q(title__icontains=term)
            | Q(description__icontains=term)
            | Q(notes__icontains=term)
            | Q(url__icontains=term)
        )
        query_set = query_set.filter(conditions)

    # Any tags - at least one tag must match
    any_tags = parse_tag_string(bundle.any_tags, " ")
    if len(any_tags) > 0:
        tag_conditions = Q()
        for tag in any_tags:
            tag_conditions |= Q(tags__name__iexact=tag)

        query_set = query_set.filter(
            Exists(Bookmark.objects.filter(tag_conditions, id=OuterRef("id")))
        )

    # All tags - all tags must match
    all_tags = parse_tag_string(bundle.all_tags, " ")
    for tag in all_tags:
        query_set = query_set.filter(tags__name__iexact=tag)

    # Excluded tags - no tags must match
    exclude_tags = parse_tag_string(bundle.excluded_tags, " ")
    if len(exclude_tags) > 0:
        tag_conditions = Q()
        for tag in exclude_tags:
            tag_conditions |= Q(tags__name__iexact=tag)
        query_set = query_set.exclude(
            Exists(Bookmark.objects.filter(tag_conditions, id=OuterRef("id")))
        )

    if bundle.filter_unread == BookmarkBundle.FILTER_STATE_YES:
        query_set = query_set.filter(unread=True)
    elif bundle.filter_unread == BookmarkBundle.FILTER_STATE_NO:
        query_set = query_set.filter(unread=False)

    if bundle.filter_shared == BookmarkBundle.FILTER_STATE_YES:
        query_set = query_set.filter(shared=True)
    elif bundle.filter_shared == BookmarkBundle.FILTER_STATE_NO:
        query_set = query_set.filter(shared=False)

    return query_set


def _base_bookmarks_query(
    user: User | None,
    profile: UserProfile,
    search: BookmarkSearch,
) -> QuerySet:
    query_set = Bookmark.objects

    # Filter for user
    if user:
        query_set = query_set.filter(owner=user)

    # Filter by modified_since if provided
    if search.modified_since:
        # If the date format is invalid, ignore the filter
        with contextlib.suppress(ValidationError):
            query_set = query_set.filter(date_modified__gt=search.modified_since)

    # Filter by added_since if provided
    if search.added_since:
        # If the date format is invalid, ignore the filter
        with contextlib.suppress(ValidationError):
            query_set = query_set.filter(date_added__gt=search.added_since)

    # Filter by search query
    if profile.legacy_search:
        query_set = _filter_search_query_legacy(query_set, search.q, profile)
    else:
        query_set = _filter_search_query(query_set, search.q, profile)

    # Unread filter from bookmark search
    if search.unread == BookmarkSearch.FILTER_UNREAD_YES:
        query_set = query_set.filter(unread=True)
    elif search.unread == BookmarkSearch.FILTER_UNREAD_NO:
        query_set = query_set.filter(unread=False)

    # Shared filter
    if search.shared == BookmarkSearch.FILTER_SHARED_SHARED:
        query_set = query_set.filter(shared=True)
    elif search.shared == BookmarkSearch.FILTER_SHARED_UNSHARED:
        query_set = query_set.filter(shared=False)

    # Filter by bundle
    if search.bundle:
        query_set = _filter_bundle(query_set, search.bundle)

    # Sort
    if (
        search.sort == BookmarkSearch.SORT_TITLE_ASC
        or search.sort == BookmarkSearch.SORT_TITLE_DESC
    ):
        # For the title, the resolved_title logic from the Bookmark entity needs
        # to be replicated as there is no corresponding database field
        query_set = query_set.annotate(
            effective_title=Case(
                When(Q(title__isnull=False) & ~Q(title__exact=""), then=Lower("title")),
                default=Lower("url"),
                output_field=CharField(),
            )
        )

        # For SQLite, if the ICU extension is loaded, use the custom collation
        # loaded into the connection. This results in an improved sort order for
        # unicode characters (umlauts, etc.)
        if settings.USE_SQLITE and settings.USE_SQLITE_ICU_EXTENSION:
            order_field = RawSQL("effective_title COLLATE ICU", ())
        else:
            order_field = "effective_title"

        if search.sort == BookmarkSearch.SORT_TITLE_ASC:
            query_set = query_set.order_by(order_field)
        elif search.sort == BookmarkSearch.SORT_TITLE_DESC:
            query_set = query_set.order_by(order_field).reverse()
    elif search.sort == BookmarkSearch.SORT_ADDED_ASC:
        query_set = query_set.order_by("date_added")
    else:
        # Sort by date added, descending by default
        query_set = query_set.order_by("-date_added")

    return query_set


def query_bookmark_tags(
    user: User, profile: UserProfile, search: BookmarkSearch
) -> QuerySet:
    bookmarks_query = query_bookmarks(user, profile, search)

    query_set = Tag.objects.filter(bookmark__in=bookmarks_query)

    return query_set.distinct()


def query_archived_bookmark_tags(
    user: User, profile: UserProfile, search: BookmarkSearch
) -> QuerySet:
    bookmarks_query = query_archived_bookmarks(user, profile, search)

    query_set = Tag.objects.filter(bookmark__in=bookmarks_query)

    return query_set.distinct()


def query_shared_bookmark_tags(
    user: User | None,
    profile: UserProfile,
    search: BookmarkSearch,
    public_only: bool,
) -> QuerySet:
    bookmarks_query = query_shared_bookmarks(user, profile, search, public_only)

    query_set = Tag.objects.filter(bookmark__in=bookmarks_query)

    return query_set.distinct()


def query_shared_bookmark_users(
    profile: UserProfile, search: BookmarkSearch, public_only: bool
) -> QuerySet:
    bookmarks_query = query_shared_bookmarks(None, profile, search, public_only)

    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 get_tags_for_query(user: User, profile: UserProfile, query: str) -> QuerySet:
    tag_names = extract_tag_names_from_query(query, profile)

    if not tag_names:
        return Tag.objects.none()

    tag_conditions = Q()
    for tag_name in tag_names:
        tag_conditions |= Q(name__iexact=tag_name)

    return Tag.objects.filter(owner=user).filter(tag_conditions).distinct()


def get_shared_tags_for_query(
    user: User | None, profile: UserProfile, query: str, public_only: bool
) -> QuerySet:
    tag_names = extract_tag_names_from_query(query, profile)

    if not tag_names:
        return Tag.objects.none()

    # Build conditions similar to query_shared_bookmarks
    conditions = Q(bookmark__shared=True) & Q(
        bookmark__owner__profile__enable_sharing=True
    )
    if public_only:
        conditions = conditions & Q(
            bookmark__owner__profile__enable_public_sharing=True
        )
    if user is not None:
        conditions = conditions & Q(bookmark__owner=user)

    tag_conditions = Q()
    for tag_name in tag_names:
        tag_conditions |= Q(name__iexact=tag_name)

    return Tag.objects.filter(conditions).filter(tag_conditions).distinct()


def parse_query_string(query_string):
    # Sanitize query params
    if not query_string:
        query_string = ""

    # Split query into search terms and tags
    keywords = query_string.strip().split(" ")
    keywords = [word for word in keywords if word]

    search_terms = [word for word in keywords if word[0] != "#" and word[0] != "!"]
    tag_names = [word[1:] for word in keywords if word[0] == "#"]
    tag_names = unique(tag_names, str.lower)

    # Special search commands
    untagged = "!untagged" in keywords
    unread = "!unread" in keywords

    return {
        "search_terms": search_terms,
        "tag_names": tag_names,
        "untagged": untagged,
        "unread": unread,
    }


================================================
FILE: bookmarks/services/__init__.py
================================================


================================================
FILE: bookmarks/services/assets.py
================================================
import gzip
import logging
import os
import shutil

import requests
from django.conf import settings
from django.core.files.uploadedfile import UploadedFile
from django.utils import formats, timezone

from bookmarks.models import Bookmark, BookmarkAsset
from bookmarks.services import singlefile
from bookmarks.services.website_loader import (
    detect_content_type,
    fake_request_headers,
    is_pdf_content_type,
)

MAX_ASSET_FILENAME_LENGTH = 192

logger = logging.getLogger(__name__)


class PdfTooLargeError(Exception):
    pass


def create_snapshot_asset(bookmark: Bookmark) -> BookmarkAsset:
    asset = BookmarkAsset(
        bookmark=bookmark,
        asset_type=BookmarkAsset.TYPE_SNAPSHOT,
        date_created=timezone.now(),
        content_type="",
        display_name="New snapshot",
        status=BookmarkAsset.STATUS_PENDING,
    )
    return asset


def create_snapshot(asset: BookmarkAsset):
    try:
        url = asset.bookmark.url
        content_type = detect_content_type(url)

        if is_pdf_content_type(content_type):
            _create_pdf_snapshot(asset)
        else:
            _create_html_snapshot(asset)
    except Exception as error:
        asset.status = BookmarkAsset.STATUS_FAILURE
        asset.save()
        raise error


def _create_html_snapshot(asset: BookmarkAsset):
    # Create snapshot into temporary file
    temp_filename = _generate_asset_filename(asset, asset.bookmark.url, "tmp")
    temp_filepath = os.path.join(settings.LD_ASSET_FOLDER, temp_filename)
    singlefile.create_snapshot(asset.bookmark.url, temp_filepath)

    # Store as gzip in asset folder
    filename = _generate_asset_filename(asset, asset.bookmark.url, "html.gz")
    filepath = os.path.join(settings.LD_ASSET_FOLDER, filename)
    with (
        open(temp_filepath, "rb") as temp_file,
        gzip.open(filepath, "wb") as gz_file,
    ):
        shutil.copyfileobj(temp_file, gz_file)

    # Remove temporary file
    os.remove(temp_filepath)

    # Update display name for HTML
    timestamp = formats.date_format(asset.date_created, "SHORT_DATE_FORMAT")

    asset.status = BookmarkAsset.STATUS_COMPLETE
    asset.content_type = BookmarkAsset.CONTENT_TYPE_HTML
    asset.display_name = f"HTML snapshot from {timestamp}"
    asset.file = filename
    asset.gzip = True
    asset.save()

    asset.bookmark.latest_snapshot = asset
    asset.bookmark.date_modified = timezone.now()
    asset.bookmark.save()


def _create_pdf_snapshot(asset: BookmarkAsset):
    url = asset.bookmark.url
    max_size = settings.LD_SNAPSHOT_PDF_MAX_SIZE

    # Download PDF to temporary file
    temp_filename = _generate_asset_filename(asset, url, "tmp")
    temp_filepath = os.path.join(settings.LD_ASSET_FOLDER, temp_filename)

    headers = fake_request_headers()
    timeout = 60

    with requests.get(url, headers=headers, stream=True, timeout=timeout) as response:
        response.raise_for_status()

        # Check Content-Length header if available
        content_length = response.headers.get("Content-Length")
        if content_length and int(content_length) > max_size:
            raise PdfTooLargeError(
                f"PDF size ({content_length} bytes) exceeds limit ({max_size} bytes)"
            )

        # Download in chunks, tracking size
        downloaded_size = 0
        with open(temp_filepath, "wb") as f:
            for chunk in response.iter_content(chunk_size=8192):
                downloaded_size += len(chunk)
                if downloaded_size > max_size:
                    raise PdfTooLargeError(f"PDF size exceeds limit ({max_size} bytes)")
                f.write(chunk)

    # Store as gzip in asset folder
    filename = _generate_asset_filename(asset, url, "pdf.gz")
    filepath = os.path.join(settings.LD_ASSET_FOLDER, filename)
    with (
        open(temp_filepath, "rb") as temp_file,
        gzip.open(filepath, "wb") as gz_file,
    ):
        shutil.copyfileobj(temp_file, gz_file)

    # Remove temporary file
    os.remove(temp_filepath)

    # Update display name for PDF
    timestamp = formats.date_format(asset.date_created, "SHORT_DATE_FORMAT")

    asset.status = BookmarkAsset.STATUS_COMPLETE
    asset.content_type = BookmarkAsset.CONTENT_TYPE_PDF
    asset.display_name = f"PDF download from {timestamp}"
    asset.file = filename
    asset.gzip = True
    asset.save()

    asset.bookmark.latest_snapshot = asset
    asset.bookmark.date_modified = timezone.now()
    asset.bookmark.save()


def upload_snapshot(bookmark: Bookmark, html: bytes):
    asset = create_snapshot_asset(bookmark)
    filename = _generate_asset_filename(asset, asset.bookmark.url, "html.gz")
    filepath = os.path.join(settings.LD_ASSET_FOLDER, filename)

    with gzip.open(filepath, "wb") as gz_file:
        gz_file.write(html)

    # Only save the asset if the file was written successfully
    timestamp = formats.date_format(asset.date_created, "SHORT_DATE_FORMAT")

    asset.status = BookmarkAsset.STATUS_COMPLETE
    asset.content_type = BookmarkAsset.CONTENT_TYPE_HTML
    asset.display_name = f"HTML snapshot from {timestamp}"
    asset.file = filename
    asset.gzip = True
    asset.save()

    asset.bookmark.latest_snapshot = asset
    asset.bookmark.date_modified = timezone.now()
    asset.bookmark.save()

    return asset


def upload_asset(bookmark: Bookmark, upload_file: UploadedFile):
    try:
        asset = BookmarkAsset(
            bookmark=bookmark,
            asset_type=BookmarkAsset.TYPE_UPLOAD,
            date_created=timezone.now(),
            content_type=upload_file.content_type,
            display_name=upload_file.name,
            status=BookmarkAsset.STATUS_COMPLETE,
            gzip=False,
        )
        name, extension = os.path.splitext(upload_file.name)

        # automatically gzip the file if it is not already gzipped
        if upload_file.content_type != "application/gzip":
            filename = _generate_asset_filename(
                asset, name, extension.lstrip(".") + ".gz"
            )
            filepath = os.path.join(settings.LD_ASSET_FOLDER, filename)
            with gzip.open(filepath, "wb", compresslevel=9) as f:
                for chunk in upload_file.chunks():
                    f.write(chunk)
            asset.gzip = True
            asset.file = filename
            asset.file_size = os.path.getsize(filepath)
        else:
            filename = _generate_asset_filename(asset, name, extension.lstrip("."))
            filepath = os.path.join(settings.LD_ASSET_FOLDER, filename)
            with open(filepath, "wb") as f:
                for chunk in upload_file.chunks():
                    f.write(chunk)
            asset.file = filename
            asset.file_size = upload_file.size

        asset.save()

        asset.bookmark.date_modified = timezone.now()
        asset.bookmark.save()

        logger.info(
            f"Successfully uploaded asset file. bookmark={bookmark} file={upload_file.name}"
        )
        return asset
    except Exception as e:
        logger.error(
            f"Failed to upload asset file. bookmark={bookmark} file={upload_file.name}",
            exc_info=e,
        )
        raise e


def remove_asset(asset: BookmarkAsset):
    # If this asset is the latest_snapshot for a bookmark, try to find the next most recent snapshot
    bookmark = asset.bookmark
    if bookmark and bookmark.latest_snapshot == asset:
        latest = (
            BookmarkAsset.objects.filter(
                bookmark=bookmark,
                asset_type=BookmarkAsset.TYPE_SNAPSHOT,
                status=BookmarkAsset.STATUS_COMPLETE,
            )
            .exclude(pk=asset.pk)
            .order_by("-date_created")
            .first()
        )

        bookmark.latest_snapshot = latest

    asset.delete()
    bookmark.date_modified = timezone.now()
    bookmark.save()


def _generate_asset_filename(
    asset: BookmarkAsset, filename: str, extension: str
) -> str:
    def sanitize_char(char):
        if char.isalnum() or char in ("-", "_", "."):
            return char
        else:
            return "_"

    formatted_datetime = asset.date_created.strftime("%Y-%m-%d_%H%M%S")
    sanitized_filename = "".join(sanitize_char(char) for char in filename)

    # Calculate the length of fixed parts of the final filename
    non_filename_length = len(f"{asset.asset_type}_{formatted_datetime}_.{extension}")
    # Calculate the maximum length for the dynamic part of the filename
    max_filename_length = MAX_ASSET_FILENAME_LENGTH - non_filename_length
    # Truncate the filename if necessary
    sanitized_filename = sanitized_filename[:max_filename_length]

    return f"{asset.asset_type}_{formatted_datetime}_{sanitized_filename}.{extension}"


================================================
FILE: bookmarks/services/auto_tagging.py
================================================
import re
from urllib.parse import parse_qs, urlparse

import idna


def get_tags(script: str, url: str):
    parsed_url = urlparse(url.lower())
    result = set()

    if not parsed_url.hostname:
        return result

    for line in script.lower().split("\n"):
        line = line.strip()

        # Skip empty lines or lines that start with a comment
        if not line or line.startswith("#"):
            continue

        # Remove trailing comment - only if # is preceded by whitespace
        comment_match = re.search(r"\s+#", line)
        if comment_match:
            line = line[: comment_match.start()]

        # Ignore lines that don't contain a URL and a tag
        parts = line.split()
        if len(parts) < 2:
            continue

        # to parse a host name from the pattern URL, ensure it has a scheme
        pattern_url = "//" + re.sub("^https?://", "", parts[0])
        parsed_pattern = urlparse(pattern_url)

        if not _domains_matches(parsed_pattern.hostname, parsed_url.hostname):
            continue

        if parsed_pattern.path and not _path_matches(
            parsed_pattern.path, parsed_url.path
        ):
            continue

        if parsed_pattern.query and not _qs_matches(
            parsed_pattern.query, parsed_url.query
        ):
            continue

        if parsed_pattern.fragment and not _fragment_matches(
            parsed_pattern.fragment, parsed_url.fragment
        ):
            continue

        for tag in parts[1:]:
            result.add(tag)

    return result


def _path_matches(expected_path: str, actual_path: str) -> bool:
    return actual_path.startswith(expected_path)


def _domains_matches(expected_domain: str, actual_domain: str) -> bool:
    expected_domain = idna.encode(expected_domain)
    actual_domain = idna.encode(actual_domain)

    return actual_domain.endswith(expected_domain)


def _qs_matches(expected_qs: str, actual_qs: str) -> bool:
    expected_qs = parse_qs(expected_qs, keep_blank_values=True)
    actual_qs = parse_qs(actual_qs, keep_blank_values=True)

    for key in expected_qs:
        if key not in actual_qs:
            return False
        for value in expected_qs[key]:
            if value != "" and value not in actual_qs[key]:
                return False

    return True


def _fragment_matches(expected_fragment: str, actual_fragment: str) -> bool:
    return actual_fragment.startswith(expected_fragment)


================================================
FILE: bookmarks/services/bookmarks.py
================================================
import logging

from django.utils import timezone

from bookmarks.models import Bookmark, User, parse_tag_string
from bookmarks.services import auto_tagging, tasks, website_loader
from bookmarks.services.tags import get_or_create_tags

logger = logging.getLogger(__name__)


def create_bookmark(
    bookmark: Bookmark,
    tag_string: str,
    current_user: User,
    disable_html_snapshot: bool = False,
):
    # If URL is already bookmarked, then update it
    existing_bookmark: Bookmark = Bookmark.query_existing(
        current_user, bookmark.url
    ).first()

    if existing_bookmark is not None:
        _merge_bookmark_data(bookmark, existing_bookmark)
        return update_bookmark(existing_bookmark, tag_string, current_user)

    # Set currently logged in user as owner
    bookmark.owner = current_user
    # Set dates only if not already provided
    # This allows to sync existing dates through the REST API for example
    if not bookmark.date_added:
        bookmark.date_added = timezone.now()
    if not bookmark.date_modified:
        bookmark.date_modified = timezone.now()
    bookmark.save()
    # Update tag list
    _update_bookmark_tags(bookmark, tag_string, current_user)
    bookmark.save()
    # Create snapshot on web archive
    tasks.create_web_archive_snapshot(current_user, bookmark, False)
    # Load favicon
    tasks.load_favicon(current_user, bookmark)
    # Load preview image
    tasks.load_preview_image(current_user, bookmark)
    # Create HTML snapshot
    if (
        current_user.profile.enable_automatic_html_snapshots
        and not disable_html_snapshot
    ):
        tasks.create_html_snapshot(bookmark)

    return bookmark


def update_bookmark(bookmark: Bookmark, tag_string, current_user: User):
    # Detect URL change
    original_bookmark = Bookmark.objects.get(id=bookmark.id)
    has_url_changed = original_bookmark.url != bookmark.url
    # Update tag list
    _update_bookmark_tags(bookmark, tag_string, current_user)
    # Update dates
    bookmark.date_modified = timezone.now()
    bookmark.save()
    # Update favicon
    tasks.load_favicon(current_user, bookmark)
    # Update preview image
    tasks.load_preview_image(current_user, bookmark)

    if has_url_changed:
        # Update web archive snapshot, if URL changed
        tasks.create_web_archive_snapshot(current_user, bookmark, True)

    return bookmark


def enhance_with_website_metadata(bookmark: Bookmark):
    metadata = website_loader.load_website_metadata(bookmark.url)
    if not bookmark.title:
        bookmark.title = metadata.title or ""

    if not bookmark.description:
        bookmark.description = metadata.description or ""

    bookmark.save()


def archive_bookmark(bookmark: Bookmark):
    bookmark.is_archived = True
    bookmark.date_modified = timezone.now()
    bookmark.save()
    return bookmark


def archive_bookmarks(bookmark_ids: [int | str], current_user: User):
    sanitized_bookmark_ids = _sanitize_id_list(bookmark_ids)

    Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids).update(
        is_archived=True, date_modified=timezone.now()
    )


def unarchive_bookmark(bookmark: Bookmark):
    bookmark.is_archived = False
    bookmark.date_modified = timezone.now()
    bookmark.save()
    return bookmark


def unarchive_bookmarks(bookmark_ids: [int | str], current_user: User):
    sanitized_bookmark_ids = _sanitize_id_list(bookmark_ids)

    Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids).update(
        is_archived=False, date_modified=timezone.now()
    )


def delete_bookmarks(bookmark_ids: [int | str], current_user: User):
    sanitized_bookmark_ids = _sanitize_id_list(bookmark_ids)

    Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids).delete()


def tag_bookmarks(bookmark_ids: [int | str], tag_string: str, current_user: User):
    sanitized_bookmark_ids = _sanitize_id_list(bookmark_ids)
    owned_bookmark_ids = Bookmark.objects.filter(
        owner=current_user, id__in=sanitized_bookmark_ids
    ).values_list("id", flat=True)
    tag_names = parse_tag_string(tag_string)
    tags = get_or_create_tags(tag_names, current_user)

    BookmarkToTagRelationShip = Bookmark.tags.through
    relationships = []
    for tag in tags:
        for bookmark_id in owned_bookmark_ids:
            relationships.append(
                BookmarkToTagRelationShip(bookmark_id=bookmark_id, tag=tag)
            )

    # Insert all bookmark -> tag associations at once, should ignore errors if association already exists
    BookmarkToTagRelationShip.objects.bulk_create(relationships, ignore_conflicts=True)
    Bookmark.objects.filter(id__in=owned_bookmark_ids).update(
        date_modified=timezone.now()
    )


def untag_bookmarks(bookmark_ids: [int | str], tag_string: str, current_user: User):
    sanitized_bookmark_ids = _sanitize_id_list(bookmark_ids)
    owned_bookmark_ids = Bookmark.objects.filter(
        owner=current_user, id__in=sanitized_bookmark_ids
    ).values_list("id", flat=True)
    tag_names = parse_tag_string(tag_string)
    tags = get_or_create_tags(tag_names, current_user)

    BookmarkToTagRelationShip = Bookmark.tags.through
    for tag in tags:
        # Remove all bookmark -> tag associations for the owned bookmarks and the current tag
        BookmarkToTagRelationShip.objects.filter(
            bookmark_id__in=owned_bookmark_ids, tag=tag
        ).delete()

    Bookmark.objects.filter(id__in=owned_bookmark_ids).update(
        date_modified=timezone.now()
    )


def mark_bookmarks_as_read(bookmark_ids: [int | str], current_user: User):
    sanitized_bookmark_ids = _sanitize_id_list(bookmark_ids)

    Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids).update(
        unread=False, date_modified=timezone.now()
    )


def mark_bookmarks_as_unread(bookmark_ids: [int | str], current_user: User):
    sanitized_bookmark_ids = _sanitize_id_list(bookmark_ids)

    Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids).update(
        unread=True, date_modified=timezone.now()
    )


def share_bookmarks(bookmark_ids: [int | str], current_user: User):
    sanitized_bookmark_ids = _sanitize_id_list(bookmark_ids)

    Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids).update(
        shared=True, date_modified=timezone.now()
    )


def unshare_bookmarks(bookmark_ids: [int | str], current_user: User):
    sanitized_bookmark_ids = _sanitize_id_list(bookmark_ids)

    Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids).update(
        shared=False, date_modified=timezone.now()
    )


def refresh_bookmarks_metadata(bookmark_ids: [int | str], current_user: User):
    sanitized_bookmark_ids = _sanitize_id_list(bookmark_ids)
    owned_bookmarks = Bookmark.objects.filter(
        owner=current_user, id__in=sanitized_bookmark_ids
    )

    for bookmark in owned_bookmarks:
        tasks.refresh_metadata(bookmark)
        tasks.load_preview_image(current_user, bookmark)


def create_html_snapshots(bookmark_ids: list[int | str], current_user: User):
    sanitized_bookmark_ids = _sanitize_id_list(bookmark_ids)
    owned_bookmarks = Bookmark.objects.filter(
        owner=current_user, id__in=sanitized_bookmark_ids
    )

    tasks.create_html_snapshots(owned_bookmarks)


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_bookmark_tags(bookmark: Bookmark, tag_string: str, user: User):
    tag_names = parse_tag_string(tag_string)

    if user.profile.auto_tagging_rules:
        try:
            auto_tag_names = auto_tagging.get_tags(
                user.profile.auto_tagging_rules, bookmark.url
            )
            for auto_tag_name in auto_tag_names:
                if auto_tag_name not in tag_names:
                    tag_names.append(auto_tag_name)
        except Exception as e:
            logger.error(
                f"Failed to auto-tag bookmark. url={bookmark.url}",
                exc_info=e,
            )

    tags = get_or_create_tags(tag_names, user)
    bookmark.tags.set(tags)


def _sanitize_id_list(bookmark_ids: [int | str]) -> [int]:
    # Convert string ids to int if necessary
    return [int(bm_id) if isinstance(bm_id, str) else bm_id for bm_id in bookmark_ids]


================================================
FILE: bookmarks/services/bundles.py
================================================
from django.db.models import Max

from bookmarks.models import BookmarkBundle, User


def create_bundle(bundle: BookmarkBundle, current_user: User):
    bundle.owner = current_user
    if bundle.order is None:
        max_order_result = BookmarkBundle.objects.filter(owner=current_user).aggregate(
            Max("order", default=-1)
        )
        bundle.order = max_order_result["order__max"] + 1
    bundle.save()
    return bundle


def move_bundle(bundle_to_move: BookmarkBundle, new_order: int):
    user_bundles = list(
        BookmarkBundle.objects.filter(owner=bundle_to_move.owner).order_by("order")
    )

    if new_order != user_bundles.index(bundle_to_move):
        user_bundles.remove(bundle_to_move)
        user_bundles.insert(new_order, bundle_to_move)
        for bundle_index, bundle in enumerate(user_bundles):
            bundle.order = bundle_index

        BookmarkBundle.objects.bulk_update(user_bundles, ["order"])


def delete_bundle(bundle: BookmarkBundle):
    bundle.delete()

    user_bundles = BookmarkBundle.objects.filter(owner=bundle.owner).order_by("order")
    for index, user_bundle in enumerate(user_bundles):
        user_bundle.order = index
    BookmarkBundle.objects.bulk_update(user_bundles, ["order"])


================================================
FILE: bookmarks/services/exporter.py
================================================
import html

from bookmarks.models import Bookmark

BookmarkDocument = list[str]


def export_netscape_html(bookmarks: list[Bookmark]):
    doc = []
    append_header(doc)
    append_list_start(doc)
    [append_bookmark(doc, bookmark) for bookmark in bookmarks]
    append_list_end(doc)

    return "\n\r".join(doc)


def append_header(doc: BookmarkDocument):
    doc.append("<!DOCTYPE NETSCAPE-Bookmark-file-1>")
    doc.append('<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8">')
    doc.append("<TITLE>Bookmarks</TITLE>")
    doc.append("<H1>Bookmarks</H1>")


def append_list_start(doc: BookmarkDocument):
    doc.append("<DL><p>")


def append_bookmark(doc: BookmarkDocument, bookmark: Bookmark):
    url = bookmark.url
    title = html.escape(bookmark.resolved_title or "")
    desc = html.escape(bookmark.resolved_description or "")
    if bookmark.notes:
        desc += f"[linkding-notes]{html.escape(bookmark.notes)}[/linkding-notes]"
    tag_names = bookmark.tag_names
    if bookmark.is_archived:
        tag_names.append("linkding:bookmarks.archived")
    tags = ",".join(tag_names)
    toread = "1" if bookmark.unread else "0"
    private = "0" if bookmark.shared else "1"
    added = int(bookmark.date_added.timestamp())
    modified = int(bookmark.date_modified.timestamp())

    doc.append(
        f'<DT><A HREF="{url}" ADD_DATE="{added}" LAST_MODIFIED="{modified}" PRIVATE="{private}" TOREAD="{toread}" TAGS="{tags}">{title}</A>'
    )

    if desc:
        doc.append(f"<DD>{desc}")


def append_list_end(doc: BookmarkDocument):
    doc.append("</DL><p>")


================================================
FILE: bookmarks/services/favicon_loader.py
================================================
import logging
import mimetypes
import os.path
import re
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

logger = logging.getLogger(__name__)

# register mime type for .ico files, which is not included in the default
# mimetypes of the Docker image
mimetypes.add_type("image/x-icon", ".ico")


def _ensure_favicon_folder():
    Path(settings.LD_FAVICON_FOLDER).mkdir(parents=True, exist_ok=True)


def _url_to_filename(url: str) -> str:
    return re.sub(r"\W+", "_", url)


def _get_url_parameters(url: str) -> dict:
    parsed_uri = urlparse(url)
    return {
        # https://example.com/foo?bar -> https://example.com
        "url": f"{parsed_uri.scheme}://{parsed_uri.hostname}",
        # https://example.com/foo?bar -> example.com
        "domain": parsed_uri.hostname,
    }


def _get_favicon_path(favicon_file: str) -> Path:
    return Path(os.path.join(settings.LD_FAVICON_FOLDER, favicon_file))


def _check_existing_favicon(favicon_name: str):
    # return existing file if a file with the same name, ignoring extension,
    # exists and is not stale
    for filename in os.listdir(settings.LD_FAVICON_FOLDER):
        file_base_name, _ = os.path.splitext(filename)
        if file_base_name == favicon_name:
            favicon_path = _get_favicon_path(filename)
            return filename if not _is_stale(favicon_path) else None
    return None


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:
    url_parameters = _get_url_parameters(url)

    # Create favicon folder if not exists
    _ensure_favicon_folder()
    # Use scheme+hostname as favicon filename to reuse icon for all pages on the same domain
    favicon_name = _url_to_filename(url_parameters["url"])
    favicon_file = _check_existing_favicon(favicon_name)

    if not favicon_file:
        # Load favicon from provider, save to file
        favicon_url = settings.LD_FAVICON_PROVIDER.format(**url_parameters)
        logger.debug(f"Loading favicon from: {favicon_url}")
        with requests.get(favicon_url, stream=True) as response:
            content_type = response.headers["Content-Type"]
            file_extension = mimetypes.guess_extension(content_type)
            favicon_file = f"{favicon_name}{file_extension}"
            favicon_path = _get_favicon_path(favicon_file)
            with open(favicon_path, "wb") as file:
                for chunk in response.iter_content(chunk_size=8192):
                    file.write(chunk)
        logger.debug(f"Saved favicon as: {favicon_path}")

    return favicon_file


================================================
FILE: bookmarks/services/importer.py
================================================
import logging
from dataclasses import dataclass

from django.contrib.auth.models import User
from django.utils import timezone

from bookmarks.models import Bookmark, Tag
from bookmarks.services import tasks
from bookmarks.services.parser import NetscapeBookmark, parse
from bookmarks.utils import normalize_url, parse_timestamp

logger = logging.getLogger(__name__)


@dataclass
class ImportResult:
    total: int = 0
    success: int = 0
    failed: int = 0


@dataclass
class ImportOptions:
    map_private_flag: bool = False


class TagCache:
    def __init__(self, user: User):
        self.user = user
        self.cache = dict()
        # Init cache with all existing tags for that user
        tags = Tag.objects.filter(owner=user)
        for tag in tags:
            self.put(tag)

    def get(self, tag_name: str):
        tag_name_lowercase = tag_name.lower()
        if tag_name_lowercase in self.cache:
            return self.cache[tag_name_lowercase]
        else:
            return None

    def get_all(self, tag_names: list[str]):
        result = []
        for tag_name in tag_names:
            tag = self.get(tag_name)
            # Tag may not have been created if tag name exceeded maximum length
            # Prevent returning duplicates
            if tag and tag not in result:
                result.append(tag)

        return result

    def put(self, tag: Tag):
        self.cache[tag.name.lower()] = tag


def import_netscape_html(
    html: str, user: User, options: ImportOptions | None = None
) -> ImportResult:
    if options is None:
        options = ImportOptions()
    result = ImportResult()
    import_start = timezone.now()

    try:
        netscape_bookmarks = parse(html)
    except Exception:
        logging.exception("Could not read bookmarks file.")
        raise

    parse_end = timezone.now()
    logger.debug(f"Parse duration: {parse_end - import_start}")

    # Create and cache all tags beforehand
    _create_missing_tags(netscape_bookmarks, user)
    tag_cache = TagCache(user)

    # Split bookmarks to import into batches, to keep memory usage for bulk operations manageable
    batches = _get_batches(netscape_bookmarks, 200)
    for batch in batches:
        _import_batch(batch, user, options, tag_cache, result)

    # Load favicons for newly imported bookmarks
    tasks.schedule_bookmarks_without_favicons(user)
    # Load previews for newly imported bookmarks
    tasks.schedule_bookmarks_without_previews(user)

    end = timezone.now()
    logger.debug(f"Import duration: {end - import_start}")

    return result


def _create_missing_tags(netscape_bookmarks: list[NetscapeBookmark], user: User):
    tag_cache = TagCache(user)
    tags_to_create = []

    for netscape_bookmark in netscape_bookmarks:
        for tag_name in netscape_bookmark.tag_names:
            # Skip tag names that exceed the maximum allowed length
            if len(tag_name) > 64:
                logger.warning(
                    f"Ignoring tag '{tag_name}' (length {len(tag_name)}) as it exceeds maximum length of 64 characters"
                )
                continue

            tag = tag_cache.get(tag_name)
            if not tag:
                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)


def _get_batches(items: list, batch_size: int):
    batches = []
    offset = 0
    num_items = len(items)

    while offset < num_items:
        batch = items[offset : min(offset + batch_size, num_items)]
        if len(batch) > 0:
            batches.append(batch)
        offset = offset + batch_size

    return batches


def _import_batch(
    netscape_bookmarks: list[NetscapeBookmark],
    user: User,
    options: ImportOptions,
    tag_cache: TagCache,
    result: ImportResult,
):
    # Query existing bookmarks
    batch_urls = [bookmark.href for bookmark in netscape_bookmarks]
    existing_bookmarks = Bookmark.objects.filter(owner=user, url__in=batch_urls)

    # Create or update bookmarks from parsed Netscape bookmarks
    bookmarks_to_create = []
    bookmarks_to_update = []

    for netscape_bookmark in netscape_bookmarks:
        result.total = result.total + 1
        try:
            # Lookup existing bookmark by URL, or create new bookmark if there is no bookmark for that URL yet
            bookmark = next(
                (
                    bookmark
                    for bookmark in existing_bookmarks
                    if bookmark.url == netscape_bookmark.href
                ),
                None,
            )
            if not bookmark:
                bookmark = Bookmark(owner=user)
                is_update = False
            else:
                is_update = True
            # Copy data from parsed bookmark
            _copy_bookmark_data(netscape_bookmark, bookmark, options)
            # Validate bookmark fields, exclude owner to prevent n+1 database query,
            # also there is no specific validation on owner
            bookmark.clean_fields(exclude=["owner"])
            # Schedule for update or insert
            if is_update:
                bookmarks_to_update.append(bookmark)
            else:
                bookmarks_to_create.append(bookmark)

            result.success = result.success + 1
        except Exception:
            shortened_bookmark_tag_str = str(netscape_bookmark)[:100] + "..."
            logging.exception("Error importing bookmark: " + shortened_bookmark_tag_str)
            result.failed = result.failed + 1

    # Bulk update bookmarks in DB
    Bookmark.objects.bulk_update(
        bookmarks_to_update,
        [
            "url",
            "url_normalized",
            "date_added",
            "date_modified",
            "unread",
            "shared",
            "title",
            "description",
            "notes",
            "owner",
        ],
    )
    # Bulk insert new bookmarks into DB
    Bookmark.objects.bulk_create(bookmarks_to_create)

    # Bulk assign tags
    # In Django 3, bulk_create does not return the auto-generated IDs when bulk inserting,
    # so we have to reload the inserted bookmarks, and match them to the parsed bookmarks by URL
    existing_bookmarks = Bookmark.objects.filter(owner=user, url__in=batch_urls)

    BookmarkToTagRelationShip = Bookmark.tags.through
    relationships = []

    for netscape_bookmark in netscape_bookmarks:
        # Lookup bookmark by URL again
        bookmark = next(
            (
                bookmark
                for bookmark in existing_bookmarks
                if bookmark.url == netscape_bookmark.href
            ),
            None,
        )

        if not bookmark:
            # Something is wrong, we should have just created this bookmark
            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
        tags = tag_cache.get_all(netscape_bookmark.tag_names)
        for tag in tags:
            relationships.append(BookmarkToTagRelationShip(bookmark=bookmark, tag=tag))

    # Insert all bookmark -> tag associations at once, should ignore errors if association already exists
    BookmarkToTagRelationShip.objects.bulk_create(relationships, ignore_conflicts=True)


def _copy_bookmark_data(
    netscape_bookmark: NetscapeBookmark, bookmark: Bookmark, options: ImportOptions
):
    bookmark.url = netscape_bookmark.href
    bookmark.url_normalized = normalize_url(bookmark.url)
    if netscape_bookmark.date_added:
        bookmark.date_added = parse_timestamp(netscape_bookmark.date_added)
    else:
        bookmark.date_added = timezone.now()
    if netscape_bookmark.date_modified:
        bookmark.date_modified = parse_timestamp(netscape_bookmark.date_modified)
    else:
        bookmark.date_modified = bookmark.date_added
    bookmark.unread = netscape_bookmark.to_read
    if netscape_bookmark.title:
        bookmark.title = netscape_bookmark.title
    if netscape_bookmark.description:
        bookmark.description = netscape_bookmark.description
    if netscape_bookmark.notes:
        bookmark.notes = netscape_bookmark.notes
    if options.map_private_flag and not netscape_bookmark.private:
        bookmark.shared = True
    if netscape_bookmark.archived:
        bookmark.is_archived = True


================================================
FILE: bookmarks/services/monolith.py
================================================
import gzip
import os
import shutil
import subprocess

from django.conf import settings


class MonolithError(Exception):
    pass


# Monolith isn't used at the moment, as the local snapshot implementation
# switched to single-file after the prototype. Keeping this around in case
# it turns out to be useful in the future.
def create_snapshot(url: str, filepath: str):
    monolith_path = settings.LD_MONOLITH_PATH
    monolith_options = settings.LD_MONOLITH_OPTIONS
    temp_filepath = filepath + ".tmp"

    try:
        command = f"{monolith_path} '{url}' {monolith_options} -o {temp_filepath}"
        subprocess.run(command, check=True, shell=True)

        with (
            open(temp_filepath, "rb") as raw_file,
            gzip.open(filepath, "wb") as gz_file,
        ):
            shutil.copyfileobj(raw_file, gz_file)

        os.remove(temp_filepath)
    except subprocess.CalledProcessError as error:
        raise MonolithError(f"Failed to create snapshot: {error.stderr}") from error


================================================
FILE: bookmarks/services/parser.py
================================================
import contextlib
from dataclasses import dataclass
from html.parser import HTMLParser

from bookmarks.models import parse_tag_string


@dataclass
class NetscapeBookmark:
    href: str
    title: str
    description: str
    notes: str
    date_added: str
    date_modified: str
    tag_names: list[str]
    to_read: bool
    private: bool
    archived: bool


class BookmarkParser(HTMLParser):
    def __init__(self):
        super().__init__()
        self.bookmarks = []

        self.current_tag = None
        self.bookmark = None
        self.href = ""
        self.add_date = ""
        self.last_modified = ""
        self.tags = ""
        self.title = ""
        self.description = ""
        self.notes = ""
        self.toread = ""
        self.private = ""

    def handle_starttag(self, tag: str, attrs: list):
        name = "handle_start_" + tag.lower()
        if name in dir(self):
            getattr(self, name)({k.lower(): v for k, v in attrs})
        self.current_tag = tag

    def handle_endtag(self, tag: str):
        name = "handle_end_" + tag.lower()
        if name in dir(self):
            getattr(self, name)()
        self.current_tag = None

    def handle_data(self, data):
        name = f"handle_{self.current_tag}_data"
        if name in dir(self):
            getattr(self, name)(data)

    def handle_end_dl(self):
        self.add_bookmark()

    def handle_start_dt(self, attrs: dict[str, str]):
        self.add_bookmark()

    def handle_start_a(self, attrs: dict[str, str]):
        vars(self).update(attrs)
        tag_names = parse_tag_string(self.tags)
        archived = "linkding:bookmarks.archived" in self.tags
        with contextlib.suppress(ValueError):
            tag_names.remove("linkding:bookmarks.archived")

        self.bookmark = NetscapeBookmark(
            href=self.href,
            title="",
            description="",
            notes="",
            date_added=self.add_date,
            date_modified=self.last_modified,
            tag_names=tag_names,
            to_read=self.toread == "1",
            # Mark as private by default, also when attribute is not specified
            private=self.private != "0",
            archived=archived,
        )

    def handle_a_data(self, data):
        self.title = data.strip()

    def handle_dd_data(self, data):
        desc = data.strip()
        if "[linkding-notes]" in desc:
            self.notes = desc.split("[linkding-notes]")[1].split("[/linkding-notes]")[0]
        self.description = desc.split("[linkding-notes]")[0]

    def add_bookmark(self):
        if self.bookmark:
            self.bookmark.title = self.title
            self.bookmark.description = self.description
            self.bookmark.notes = self.notes
            self.bookmarks.append(self.bookmark)
        self.bookmark = None
        self.href = ""
        self.add_date = ""
        self.last_modified = ""
        self.tags = ""
        self.title = ""
        self.description = ""
        self.notes = ""
        self.toread = ""
        self.private = ""


def parse(html: str) -> list[NetscapeBookmark]:
    parser = BookmarkParser()
    parser.feed(html)
    return parser.bookmarks


================================================
FILE: bookmarks/services/preview_image_loader.py
================================================
import hashlib
import logging
import mimetypes
import os.path
from pathlib import Path

import requests
from django.conf import settings

from bookmarks.services import website_loader

logger = logging.getLogger(__name__)


def _ensure_preview_folder():
    Path(settings.LD_PREVIEW_FOLDER).mkdir(parents=True, exist_ok=True)


def _url_to_filename(preview_image: str) -> str:
    return hashlib.md5(preview_image.encode()).hexdigest()


def _get_image_path(preview_image_file: str) -> Path:
    return Path(os.path.join(settings.LD_PREVIEW_FOLDER, preview_image_file))


def load_preview_image(url: str) -> str | None:
    _ensure_preview_folder()

    metadata = website_loader.load_website_metadata(url)
    if not metadata.preview_image:
        logger.debug(f"Could not find preview image in metadata: {url}")
        return None

    image_url = metadata.preview_image

    logger.debug(f"Loading preview image: {image_url}")
    with requests.get(image_url, stream=True) as response:
        if response.status_code < 200 or response.status_code >= 300:
            logger.debug(
                f"Bad response status code for preview image: {image_url} status_code={response.status_code}"
            )
            return None

        if "Content-Length" not in response.headers:
            logger.debug(f"Empty Content-Length for preview image: {image_url}")
            return None

        content_length = int(response.headers["Content-Length"])
        if content_length > settings.LD_PREVIEW_MAX_SIZE:
            logger.debug(
                f"Content-Length exceeds LD_PREVIEW_MAX_SIZE: {image_url} length={content_length}"
            )
            return None

        if "Content-Type" not in response.headers:
            logger.debug(f"Empty Content-Type for preview image: {image_url}")
            return None

        content_type = response.headers["Content-Type"].split(";", 1)[0]
        file_extension = mimetypes.guess_extension(content_type)

        if file_extension not in settings.LD_PREVIEW_ALLOWED_EXTENSIONS:
            logger.debug(
                f"Unsupported Content-Type for preview image: {image_url} content_type={content_type}"
            )
            return None

        preview_image_hash = _url_to_filename(url)
        preview_image_file = f"{preview_image_hash}{file_extension}"
        preview_image_path = _get_image_path(preview_image_file)

        with open(preview_image_path, "wb") as file:
            downloaded = 0
            for chunk in response.iter_content(chunk_size=8192):
                downloaded += len(chunk)
                if downloaded > content_length:
                    logger.debug(
                        f"Content-Length mismatch for preview image: {image_url} length={content_length} downloaded={downloaded}"
                    )
                    file.close()
                    preview_image_path.unlink()
                    return None

                file.write(chunk)

    logger.debug(f"Saved preview image as: {preview_image_path}")

    return preview_image_file


================================================
FILE: bookmarks/services/search_query_parser.py
================================================
from dataclasses import dataclass
from enum import Enum

from bookmarks.models import UserProfile


class TokenType(Enum):
    TERM = "TERM"
    TAG = "TAG"
    SPECIAL_KEYWORD = "SPECIAL_KEYWORD"
    AND = "AND"
    OR = "OR"
    NOT = "NOT"
    LPAREN = "LPAREN"
    RPAREN = "RPAREN"
    EOF = "EOF"


@dataclass
class Token:
    type: TokenType
    value: str
    position: int


class SearchQueryTokenizer:
    def __init__(self, query: str):
        self.query = query.strip()
        self.position = 0
        self.current_char = self.query[0] if self.query else None

    def advance(self):
        """Move to the next character in the query."""
        self.position += 1
        if self.position >= len(self.query):
            self.current_char = None
        else:
            self.current_char = self.query[self.position]

    def skip_whitespace(self):
        """Skip whitespace characters."""
        while self.current_char and self.current_char.isspace():
            self.advance()

    def read_term(self) -> str:
        """Read a search term (sequence of non-whitespace, non-special characters)."""
        term = ""

        while (
            self.current_char
            and not self.current_char.isspace()
            and self.current_char not in "()\"'#!"
        ):
            term += self.current_char
            self.advance()

        return term

    def read_quoted_string(self, quote_char: str) -> str:
        """Read a quoted string, handling escaped quotes."""
        content = ""
        self.advance()  # skip opening quote

        while self.current_char and self.current_char != quote_char:
            if self.current_char == "\\":
                # Handle escaped characters
                self.advance()
                if self.current_char:
                    if self.current_char == "n":
                        content += "\n"
                    elif self.current_char == "t":
                        content += "\t"
                    elif self.current_char == "r":
                        content += "\r"
                    elif self.current_char == "\\":
                        content += "\\"
                    elif self.current_char == quote_char:
                        content += quote_char
                    else:
                        # For any other escaped character, just include it as-is
                        content += self.current_char
                    self.advance()
            else:
                content += self.current_char
                self.advance()

        if self.current_char == quote_char:
            self.advance()  # skip closing quote
        else:
            # Unclosed quote - we could raise an error here, but let's be lenient
            # and treat it as if the quote was closed at the end
            pass

        return content

    def read_tag(self) -> str:
        """Read a tag (starts with # and continues until whitespace or special chars)."""
        tag = ""
        self.advance()  # skip the # character

        while (
            self.current_char
            and not self.current_char.isspace()
            and self.current_char not in "()\"'"
        ):
            tag += self.current_char
            self.advance()

        return tag

    def read_special_keyword(self) -> str:
        """Read a special keyword (starts with ! and continues until whitespace or special chars)."""
        keyword = ""
        self.advance()  # skip the ! character

        while (
            self.current_char
            and not self.current_char.isspace()
            and self.current_char not in "()\"'"
        ):
            keyword += self.current_char
            self.advance()

        return keyword

    def tokenize(self) -> list[Token]:
        """Convert the query string into a list of tokens."""
        tokens = []

        while self.current_char:
            self.skip_whitespace()

            if not self.current_char:
                break

            start_pos = self.position

            if self.current_char == "(":
                tokens.append(Token(TokenType.LPAREN, "(", start_pos))
                self.advance()
            elif self.current_char == ")":
                tokens.append(Token(TokenType.RPAREN, ")", start_pos))
                self.advance()
            elif self.current_char in "\"'":
                # Read a quoted string - always treated as a term
                quote_char = self.current_char
                term = self.read_quoted_string(quote_char)
                tokens.append(Token(TokenType.TERM, term, start_pos))
            elif self.current_char == "#":
                # Read a tag
                tag = self.read_tag()
                # Only add the tag token if it has content
                if tag:
                    tokens.append(Token(TokenType.TAG, tag, start_pos))
            elif self.current_char == "!":
                # Read a special keyword
                keyword = self.read_special_keyword()
                # Only add the keyword token if it has content
                if keyword:
                    tokens.append(Token(TokenType.SPECIAL_KEYWORD, keyword, start_pos))
            else:
                # Read a term and check if it's an operator
                term = self.read_term()
                term_lower = term.lower()

                if term_lower == "and":
                    tokens.append(Token(TokenType.AND, term, start_pos))
                elif term_lower == "or":
                    tokens.append(Token(TokenType.OR, term, start_pos))
                elif term_lower == "not":
                    tokens.append(Token(TokenType.NOT, term, start_pos))
                else:
                    tokens.append(Token(TokenType.TERM, term, start_pos))

        tokens.append(Token(TokenType.EOF, "", len(self.query)))
        return tokens


class SearchExpression:
    pass


@dataclass
class TermExpression(SearchExpression):
    term: str


@dataclass
class TagExpression(SearchExpression):
    tag: str


@dataclass
class SpecialKeywordExpression(SearchExpression):
    keyword: str


@dataclass
class AndExpression(SearchExpression):
    left: SearchExpression
    right: SearchExpression


@dataclass
class OrExpression(SearchExpression):
    left: SearchExpression
    right: SearchExpression


@dataclass
class NotExpression(SearchExpression):
    operand: SearchExpression


class SearchQueryParseError(Exception):
    def __init__(self, message: str, position: int):
        self.message = message
        self.position = position
        super().__init__(f"{message} at position {position}")


class SearchQueryParser:
    def __init__(self, tokens: list[Token]):
        self.tokens = tokens
        self.position = 0
        self.current_token = tokens[0] if tokens else Token(TokenType.EOF, "", 0)

    def advance(self):
        """Move to the next token."""
        if self.position < len(self.tokens) - 1:
            self.position += 1
            self.current_token = self.tokens[self.position]

    def consume(self, expected_type: TokenType) -> Token:
        """Consume a token of the expected type or raise an error."""
        if self.current_token.type == expected_type:
            token = self.current_token
            self.advance()
            return token
        else:
            raise SearchQueryParseError(
                f"Expected {expected_type.value}, got {self.current_token.type.value}",
                self.current_token.position,
            )

    def parse(self) -> SearchExpression | None:
        """Parse the tokens into an AST."""
        if not self.tokens or (
            len(self.tokens) == 1 and self.tokens[0].type == TokenType.EOF
        ):
            return None

        expr = self.parse_or_expression()

        if self.current_token.type != TokenType.EOF:
            raise SearchQueryParseError(
                f"Unexpected token {self.current_token.type.value}",
                self.current_token.position,
            )

        return expr

    def parse_or_expression(self) -> SearchExpression:
        """Parse OR expressions (lowest precedence)."""
        left = self.parse_and_expression()

        while self.current_token.type == TokenType.OR:
            self.advance()  # consume OR
            right = self.parse_and_expression()
            left = OrExpression(left, right)

        return left

    def parse_and_expression(self) -> SearchExpression:
        """Parse AND expressions (medium precedence), including implicit AND."""
        left = self.parse_not_expression()

        while self.current_token.type == TokenType.AND or self.current_token.type in [
            TokenType.TERM,
            TokenType.TAG,
            TokenType.SPECIAL_KEYWORD,
            TokenType.LPAREN,
            TokenType.NOT,
        ]:
            if self.current_token.type == TokenType.AND:
                self.advance()  # consume explicit AND
            # else: implicit AND (don't advance token)

            right = self.parse_not_expression()
            left = AndExpression(left, right)

        return left

    def parse_not_expression(self) -> SearchExpression:
        """Parse NOT expressions (high precedence)."""
        if self.current_token.type == TokenType.NOT:
            self.advance()  # consume NOT
            operand = self.parse_not_expression()  # right associative
            return NotExpression(operand)

        return self.parse_primary_expression()

    def parse_primary_expression(self) -> SearchExpression:
        """Parse primary expressions (terms, tags, special keywords, and parenthesized expressions)."""
        if self.current_token.type == TokenType.TERM:
            term = self.current_token.value
            self.advance()
            return TermExpression(term)
        elif self.current_token.type == TokenType.TAG:
            tag = self.current_token.value
            self.advance()
            return TagExpression(tag)
        elif self.current_token.type == TokenType.SPECIAL_KEYWORD:
            keyword = self.current_token.value
            self.advance()
            return SpecialKeywordExpression(keyword)
        elif self.current_token.type == TokenType.LPAREN:
            self.advance()  # consume (
            expr = self.parse_or_expression()
            self.consume(TokenType.RPAREN)  # consume )
            return expr
        else:
            raise SearchQueryParseError(
                f"Unexpected token {self.current_token.type.value}",
                self.current_token.position,
            )


def parse_search_query(query: str) -> SearchExpression | None:
    if not query or not query.strip():
        return None

    tokenizer = SearchQueryTokenizer(query)
    tokens = tokenizer.tokenize()
    parser = SearchQueryParser(tokens)
    return parser.parse()


def _needs_parentheses(expr: SearchExpression, parent_type: type) -> bool:
    if isinstance(expr, OrExpression) and parent_type == AndExpression:
        return True
    # AndExpression or OrExpression needs parentheses when inside NotExpression
    return (
        isinstance(expr, (AndExpression, OrExpression)) and parent_type == NotExpression
    )


def _is_simple_expression(expr: SearchExpression) -> bool:
    """Check if an expression is simple (term, tag, or keyword)."""
    return isinstance(expr, (TermExpression, TagExpression, SpecialKeywordExpression))


def _expression_to_string(expr: SearchExpression, parent_type: type = None) -> str:
    if isinstance(expr, TermExpression):
        # Quote terms if they contain spaces or special characters
        if " " in expr.term or any(c in expr.term for c in ["(", ")", '"', "'"]):
            # Escape any quotes in the term
            escaped = expr.term.replace("\\", "\\\\").replace('"', '\\"')
            return f'"{escaped}"'
        return expr.term

    elif isinstance(expr, TagExpression):
        return f"#{expr.tag}"

    elif isinstance(expr, SpecialKeywordExpression):
        return f"!{expr.keyword}"

    elif isinstance(expr, NotExpression):
        # Don't pass parent type to children
        operand_str = _expression_to_string(expr.operand, None)
        # Add parentheses if the operand is a binary operation
        if isinstance(expr.operand, (AndExpression, OrExpression)):
            return f"not ({operand_str})"
        return f"not {operand_str}"

    elif isinstance(expr, AndExpression):
        # Don't pass parent type to children - they'll add their own parens only if needed
        left_str = _expression_to_string(expr.left, None)
        right_str = _expression_to_string(expr.right, None)

        # Add parentheses to children if needed for precedence
        if _needs_parentheses(expr.left, AndExpression):
            left_str = f"({left_str})"
        if _needs_parentheses(expr.right, AndExpression):
            right_str = f"({right_str})"

        result = f"{left_str} {right_str}"

        # Add outer parentheses if needed based on parent context
        if parent_type and _needs_parentheses(expr, parent_type):
            result = f"({result})"

        return result

    elif isinstance(expr, OrExpression):
        # Don't pass parent type to children
        left_str = _expression_to_string(expr.left, None)
        right_str = _expression_to_string(expr.right, None)

        # OrExpression children don't need parentheses unless they're also OR (handled by recursion)
        result = f"{left_str} or {right_str}"

        # Add outer parentheses if needed based on parent context
        if parent_type and _needs_parentheses(expr, parent_type):
            result = f"({result})"

        return result

    else:
        raise ValueError(f"Unknown expression type: {type(expr)}")


def expression_to_string(expr: SearchExpression | None) -> str:
    if expr is None:
        return ""
    return _expression_to_string(expr)


def _strip_tag_from_expression(
    expr: SearchExpression | None, tag_name: str, enable_lax_search: bool = False
) -> SearchExpression | None:
    if expr is None:
        return None

    if isinstance(expr, TagExpression):
        # Remove this tag if it matches
        if expr.tag.lower() == tag_name.lower():
            return None
        return expr

    elif isinstance(expr, TermExpression):
        # In lax search mode, also remove terms that match the tag name
        if enable_lax_search and expr.term.lower() == tag_name.lower():
            return None
        return expr

    elif isinstance(expr, SpecialKeywordExpression):
        # Keep special keywords as-is
        return expr

    elif isinstance(expr, NotExpression):
        # Recursively filter the operand
        filtered_operand = _strip_tag_from_expression(
            expr.operand, tag_name, enable_lax_search
        )
        if filtered_operand is None:
            # If the operand is removed, the whole NOT expression should be removed
            return None
        return NotExpression(filtered_operand)

    elif isinstance(expr, AndExpression):
        # Recursively filter both sides
        left = _strip_tag_from_expression(expr.left, tag_name, enable_lax_search)
        right = _strip_tag_from_expression(expr.right, tag_name, enable_lax_search)

        # If both sides are removed, remove the AND expression
        if left is None and right is None:
            return None
        # If one side is removed, return the other side
        elif left is None:
            return right
        elif right is None:
            return left
        else:
            return AndExpression(left, right)

    elif isinstance(expr, OrExpression):
        # Recursively filter both sides
        left = _strip_tag_from_expression(expr.left, tag_name, enable_lax_search)
        right = _strip_tag_from_expression(expr.right, tag_name, enable_lax_search)

        # If both sides are removed, remove the OR expression
        if left is None and right is None:
            return None
        # If one side is removed, return the other side
        elif left is None:
            return right
        elif right is None:
            return left
        else:
            return OrExpression(left, right)

    else:
        # Unknown expression type, return as-is
        return expr


def strip_tag_from_query(
    query: str, tag_name: str, user_profile: UserProfile | None = None
) -> str:
    try:
        ast = parse_search_query(query)
    except SearchQueryParseError:
        return query

    if ast is None:
        return ""

    # Determine if lax search is enabled
    enable_lax_search = False
    if user_profile is not None:
        enable_lax_search = user_profile.tag_search == UserProfile.TAG_SEARCH_LAX

    # Strip the tag from the AST
    filtered_ast = _strip_tag_from_expression(ast, tag_name, enable_lax_search)

    # Convert back to a query string
    return expression_to_string(filtered_ast)


def _extract_tag_names_from_expression(
    expr: SearchExpression | None, enable_lax_search: bool = False
) -> list[str]:
    if expr is None:
        return []

    if isinstance(expr, TagExpression):
        return [expr.tag]

    elif isinstance(expr, TermExpression):
        # In lax search mode, terms are also considered tags
        if enable_lax_search:
            return [expr.term]
        return []

    elif isinstance(expr, SpecialKeywordExpression):
        # Special keywords are not tags
        return []

    elif isinstance(expr, NotExpression):
        # Recursively extract from the operand
        return _extract_tag_names_from_expression(expr.operand, enable_lax_search)

    elif isinstance(expr, (AndExpression, OrExpression)):
        # Recursively extract from both sides and combine
        left_tags = _extract_tag_names_from_expression(expr.left, enable_lax_search)
        right_tags = _extract_tag_names_from_expression(expr.right, enable_lax_search)
        return left_tags + right_tags

    else:
        # Unknown expression type
        return []


def extract_tag_names_from_query(
    query: str, user_profile: UserProfile | None = None
) -> list[str]:
    try:
        ast = parse_search_query(query)
    except SearchQueryParseError:
        return []

    if ast is None:
        return []

    # Determine if lax search is enabled
    enable_lax_search = False
    if user_profile is not None:
        enable_lax_search = user_profile.tag_search == UserProfile.TAG_SEARCH_LAX

    # Extract tag names from the AST
    tag_names = _extract_tag_names_from_expression(ast, enable_lax_search)

    # Deduplicate (case-insensitive) and sort
    seen = set()
    unique_tags = []
    for tag in tag_names:
        tag_lower = tag.lower()
        if tag_lower not in seen:
            seen.add(tag_lower)
            unique_tags.append(tag_lower)

    return sorted(unique_tags)


================================================
FILE: bookmarks/services/singlefile.py
================================================
import logging
import os
import shlex
import signal
import subprocess

from django.conf import settings


class SingleFileError(Exception):
    pass


logger = logging.getLogger(__name__)


def create_snapshot(url: str, filepath: str):
    singlefile_path = settings.LD_SINGLEFILE_PATH

    # parse options to list of arguments
    ublock_options = shlex.split(settings.LD_SINGLEFILE_UBLOCK_OPTIONS)
    custom_options = shlex.split(settings.LD_SINGLEFILE_OPTIONS)
    # concat lists
    args = [singlefile_path] + ublock_options + custom_options + [url, filepath]
    try:
        # Use start_new_session=True to create a new process group
        process = subprocess.Popen(args, start_new_session=True)
        process.wait(timeout=settings.LD_SINGLEFILE_TIMEOUT_SEC)

        # check if the file was created
        if not os.path.exists(filepath):
            raise SingleFileError("Failed to create snapshot")
    except subprocess.TimeoutExpired:
        # First try to terminate properly
        try:
            logger.error(
                "Timeout expired while creating snapshot. Terminating process..."
            )
            process.terminate()
            process.wait(timeout=20)
            raise SingleFileError("Timeout expired while creating snapshot") from None
        except subprocess.TimeoutExpired:
            # Kill the whole process group, which should also clean up any chromium
            # processes spawned by single-file
            logger.error("Timeout expired while terminating. Killing process...")
            os.killpg(os.getpgid(process.pid), signal.SIGTERM)
            raise SingleFileError("Timeout expired while creating snapshot") from None
    except subprocess.CalledProcessError as error:
        raise SingleFileError(f"Failed to create snapshot: {error.stderr}") from error


================================================
FILE: bookmarks/services/tags.py
================================================
import logging
import operator

from django.contrib.auth.models import User
from django.utils import timezone

from bookmarks.models import Tag
from bookmarks.utils import unique

logger = logging.getLogger(__name__)


def get_or_create_tags(tag_names: list[str], user: User):
    tags = [get_or_create_tag(tag_name, user) for tag_name in tag_names]
    return unique(tags, operator.attrgetter("id"))


def get_or_create_tag(name: str, user: User):
    try:
        return Tag.objects.get(name__iexact=name, owner=user)
    except Tag.DoesNotExist:
        tag = Tag(name=name, owner=user)
        tag.date_added = timezone.now()
        tag.save()
        return tag
    except Tag.MultipleObjectsReturned:
        # Legacy databases might contain duplicate tags with different capitalization
        first_tag = Tag.objects.filter(name__iexact=name, owner=user).first()
        message = (
            f"Found multiple tags for the name '{name}' with different capitalization. "
            f"Using the first tag with the name '{first_tag.name}'. "
            "Since v.1.2 tags work case-insensitive, which means duplicates of the same name are not allowed anymore. "
            "To solve this error remove the duplicate tag in admin."
        )
        logger.error(message)
        return first_tag


================================================
FILE: bookmarks/services/tasks.py
================================================
import functools
import logging

import waybackpy
from django.conf import settings
from django.contrib.auth.models import User
from django.db.models import Q
from django.utils import timezone
from huey import crontab
from huey.contrib.djhuey import HUEY as huey
from huey.exceptions import TaskLockedException
from waybackpy.exceptions import TooManyRequestsError, WaybackError

from bookmarks.models import Bookmark, BookmarkAsset, UserProfile
from bookmarks.services import assets, favicon_loader, preview_image_loader
from bookmarks.services.website_loader import DEFAULT_USER_AGENT, load_website_metadata

logger = logging.getLogger(__name__)


# Create custom decorator for Huey tasks that implements exponential backoff
# Taken from: https://huey.readthedocs.io/en/latest/guide.html#tips-and-tricks
# Retry 1: 60
# Retry 2: 240
# Retry 3: 960
# Retry 4: 3840
# Retry 5: 15360
def task(retries=5, retry_delay=15, retry_backoff=4):
    def deco(fn):
        @functools.wraps(fn)
        def inner(*args, **kwargs):
            task = kwargs.pop("task")
            try:
                return fn(*args, **kwargs)
            except TaskLockedException as exc:
                # Task locks are currently only used as workaround to enforce
                # running specific types of tasks (e.g. singlefile snapshots)
                # sequentially. In that case don't reduce the number of retries.
                task.retries = retries
                raise exc
            except Exception as exc:
                task.retry_delay *= retry_backoff
                raise exc

        return huey.task(retries=retries, retry_delay=retry_delay, context=True)(inner)

    return deco


def is_web_archive_integration_active(user: User) -> bool:
    background_tasks_enabled = not settings.LD_DISABLE_BACKGROUND_TASKS
    web_archive_integration_enabled = (
        user.profile.web_archive_integration
        == UserProfile.WEB_ARCHIVE_INTEGRATION_ENABLED
    )

    return background_tasks_enabled and web_archive_integration_enabled


def create_web_archive_snapshot(user: User, bookmark: Bookmark, force_update: bool):
    if is_web_archive_integration_active(user):
        _create_web_archive_snapshot_task(bookmark.id, force_update)


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}")


@task()
def _create_web_archive_snapshot_task(bookmark_id: int, force_update: bool):
    try:
        bookmark = Bookmark.objects.get(id=bookmark_id)
    except Bookmark.DoesNotExist:
        return

    # Skip if snapshot exists and update is not explicitly requested
    if bookmark.web_archive_snapshot_url and not force_update:
        return

    # Create new snapshot
    try:
        _create_snapshot(bookmark)
        return
    except TooManyRequestsError:
        logger.error(
            f"Failed to create snapshot due to rate limiting. url={bookmark.url}"
        )
    except WaybackError as error:
        logger.error(
            f"Failed to create snapshot. url={bookmark.url}",
            exc_info=error,
        )


@task()
def _load_web_archive_snapshot_task(bookmark_id: int):
    # Loading snapshots from CDX API has been removed, keeping the task function
    # for now to prevent errors when huey tries to run the task
    pass


@task()
def _schedule_bookmarks_without_snapshots_task(user_id: int):
    # Loading snapshots from CDX API has been removed, keeping the task function
    # for now to prevent errors when huey tries to run the task
    pass


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 is_preview_feature_active(user: User) -> bool:
    return (
        user.profile.enable_preview_images and not settings.LD_DISABLE_BACKGROUND_TASKS
    )


def load_favicon(user: User, bookmark: Bookmark):
    if is_favicon_feature_active(user):
        _load_favicon_task(bookmark.id)


@task()
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_file = favicon_loader.load_favicon(bookmark.url)

    if new_favicon_file != bookmark.favicon_file:
        bookmark.favicon_file = new_favicon_file
        bookmark.save(update_fields=["favicon_file"])
        logger.info(
            f"Successfully updated favicon for bookmark. url={bookmark.url} icon={new_favicon_file}"
        )


def schedule_bookmarks_without_favicons(user: User):
    if is_favicon_feature_active(user):
        _schedule_bookmarks_without_favicons_task(user.id)


@task()
def _schedule_bookmarks_without_favicons_task(user_id: int):
    user = User.objects.get(id=user_id)
    bookmarks = Bookmark.objects.filter(favicon_file__exact="", owner=user)

    # TODO: Implement bulk task creation
    for bookmark in bookmarks:
        _load_favicon_task(bookmark.id)
        pass


def schedule_refresh_favicons(user: User):
    if is_favicon_feature_active(user) and settings.LD_ENABLE_REFRESH_FAVICONS:
        _schedule_refresh_favicons_task(user.id)


@task()
def _schedule_refresh_favicons_task(user_id: int):
    user = User.objects.get(id=user_id)
    bookmarks = Bookmark.objects.filter(owner=user)

    # TODO: Implement bulk task creation
    for bookmark in bookmarks:
        _load_favicon_task(bookmark.id)


def load_preview_image(user: User, bookmark: Bookmark):
    if is_preview_feature_active(user):
        _load_preview_image_task(bookmark.id)


@task()
def _load_preview_image_task(bookmark_id: int):
    try:
        bookmark = Bookmark.objects.get(id=bookmark_id)
    except Bookmark.DoesNotExist:
        return

    logger.info(f"Load preview image for bookmark. url={bookmark.url}")

    new_preview_image_file = preview_image_loader.load_preview_image(bookmark.url)

    if new_preview_image_file != bookmark.preview_image_file:
        bookmark.preview_image_file = new_preview_image_file or ""
        bookmark.save(update_fields=["preview_image_file"])
        logger.info(
            f"Successfully updated preview image for bookmark. url={bookmark.url} preview_image_file={new_preview_image_file}"
        )


def schedule_bookmarks_without_previews(user: User):
    if is_preview_feature_active(user):
        _schedule_bookmarks_without_previews_task(user.id)


@task()
def _schedule_bookmarks_without_previews_task(user_id: int):
    user = User.objects.get(id=user_id)
    bookmarks = Bookmark.objects.filter(
        Q(preview_image_file__exact=""),
        owner=user,
    )

    # TODO: Implement bulk task creation
    for bookmark in bookmarks:
        try:
            _load_preview_image_task(bookmark.id)
        except Exception as exc:
            logging.exception(exc)


def refresh_metadata(bookmark: Bookmark):
    if not settings.LD_DISABLE_BACKGROUND_TASKS:
        _refresh_metadata_task(bookmark.id)


@task()
def _refresh_metadata_task(bookmark_id: int):
    try:
        bookmark = Bookmark.objects.get(id=bookmark_id)
    except Bookmark.DoesNotExist:
        return

    logger.info(f"Refresh metadata for bookmark. url={bookmark.url}")

    metadata = load_website_metadata(bookmark.url)
    if metadata.title:
        bookmark.title = metadata.title
    if metadata.description:
        bookmark.description = metadata.description
    bookmark.date_modified = timezone.now()

    bookmark.save()
    logger.info(f"Successfully refreshed metadata for bookmark. url={bookmark.url}")


def is_html_snapshot_feature_active() -> bool:
    return settings.LD_ENABLE_SNAPSHOTS and not settings.LD_DISABLE_BACKGROUND_TASKS


def create_html_snapshot(bookmark: Bookmark):
    if not is_html_snapshot_feature_active():
        return

    asset = assets.create_snapshot_asset(bookmark)
    asset.save()


def create_html_snapshots(bookmark_list: list[Bookmark]):
    if not is_html_snapshot_feature_active():
        return

    assets_to_create = []
    for bookmark in bookmark_list:
        asset = assets.create_snapshot_asset(bookmark)
        assets_to_create.append(asset)

    BookmarkAsset.objects.bulk_create(assets_to_create)


# singe-file does not support running multiple instances in parallel, so we can
# not queue up multiple snapshot tasks at once. Instead, schedule a periodic
# task that grabs a number of pending assets and creates snapshots for them in
# sequence. The task uses a lock to ensure that a new task isn't scheduled
# before the previous one has finished.
@huey.periodic_task(crontab(minute="*"))
@huey.lock_task("schedule-html-snapshots-lock")
def _schedule_html_snapshots_task():
    # Get five pending assets
    assets = BookmarkAsset.objects.filter(status=BookmarkAsset.STATUS_PENDING).order_by(
        "date_created"
    )[:5]

    for asset in assets:
        _create_html_snapshot_task(asset.id)


def _create_html_snapshot_task(asset_id: int):
    try:
        asset = BookmarkAsset.objects.get(id=asset_id)
    except BookmarkAsset.DoesNotExist:
        return

    logger.info(f"Create HTML snapshot for bookmark. url={asset.bookmark.url}")

    try:
        assets.create_snapshot(asset)

        logger.info(
            f"Successfully created HTML snapshot for bookmark. url={asset.bookmark.url}"
        )
    except Exception as error:
        logger.error(
            f"Failed to HTML snapshot for bookmark. url={asset.bookmark.url}",
            exc_info=error,
        )


def create_missing_html_snapshots(user: User) -> int:
    if not is_html_snapshot_feature_active():
        return 0

    bookmarks_without_snapshots = Bookmark.objects.filter(owner=user).exclude(
        bookmarkasset__asset_type=BookmarkAsset.TYPE_SNAPSHOT,
        bookmarkasset__status__in=[
            BookmarkAsset.STATUS_PENDING,
            BookmarkAsset.STATUS_COMPLETE,
        ],
    )
    bookmarks_without_snapshots |= Bookmark.objects.filter(owner=user).exclude(
        bookmarkasset__asset_type=BookmarkAsset.TYPE_SNAPSHOT
    )

    create_html_snapshots(list(bookmarks_without_snapshots))

    return bookmarks_without_snapshots.count()


================================================
FILE: bookmarks/services/wayback.py
================================================
import datetime

from django.utils import timezone


def generate_fallback_webarchive_url(
    url: str, timestamp: datetime.datetime
) -> str | None:
    """
    Generate a URL to the web archive for the given URL and timestamp.
    A snapshot for the specific timestamp might not exist, in which case the
    web archive will show the closest snapshot to the given timestamp.
    If there is no snapshot at all the URL will be invalid.
    """
    if not url:
        return None
    if not timestamp:
        timestamp = timezone.now()

    return f"https://web.archive.org/web/{timestamp.strftime('%Y%m%d%H%M%S')}/{url}"


================================================
FILE: bookmarks/services/website_loader.py
================================================
import logging
from dataclasses import dataclass
from functools import lru_cache
from urllib.parse import urljoin

import requests
from bs4 import BeautifulSoup
from charset_normalizer import from_bytes
from django.utils import timezone

logger = logging.getLogger(__name__)


@dataclass
class WebsiteMetadata:
    url: str
    title: str | None
    description: str | None
    preview_image: str | None

    def to_dict(self):
        return {
            "url": self.url,
            "title": self.title,
            "description": self.description,
            "preview_image": self.preview_image,
        }


def load_website_metadata(url: str, ignore_cache: bool = False):
    if ignore_cache:
        return _load_website_metadata(url)
    return _load_website_metadata_cached(url)


# 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_cached(url: str):
    return _load_website_metadata(url)


def _load_website_metadata(url: str):
    title = None
    description = None
    preview_image = 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")

        if soup.title and soup.title.string:
            title = soup.title.string.strip()
        description_tag = soup.find("meta", attrs={"name": "description"})
        description = (
            description_tag["content"].strip()
            if description_tag and description_tag["content"]
            else None
        )

        if not description:
            description_tag = soup.find("meta", attrs={"property": "og:description"})
            description = (
                description_tag["content"].strip()
                if description_tag and description_tag["content"]
                else None
            )

        image_tag = soup.find("meta", attrs={"property": "og:image"})
        preview_image = image_tag["content"].strip() if image_tag else None
        if (
            preview_image
            and not preview_image.startswith("http://")
            and not preview_image.startswith("https://")
        ):
            preview_image = urljoin(url, preview_image)

        end = timezone.now()
        logger.debug(f"Parsing duration: {end - start}")
    except Exception:
        pass

    return WebsiteMetadata(
        url=url, title=title, description=description, preview_image=preview_image
    )


CHUNK_SIZE = 50 * 1024
MAX_CONTENT_LIMIT = 5000 * 1024


def load_page(url: str):
    headers = fake_request_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
            content = chunk if content is None else 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 = b"</head>"
            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(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": DEFAULT_USER_AGENT,
    }


def detect_content_type(url: str, timeout: int = 10) -> str | None:
    """Make HEAD request to detect content type of URL. Returns None on failure."""
    headers = fake_request_headers()

    try:
        response = requests.head(
            url, headers=headers, timeout=timeout, allow_redirects=True
        )
        if response.status_code == 200:
            return (
                response.headers.get("Content-Type", "").split(";")[0].strip().lower()
            )
    except requests.RequestException:
        pass

    try:
        with requests.get(
            url, headers=headers, timeout=timeout, stream=True, allow_redirects=True
        ) as response:
            if response.status_code == 200:
                return (
                    response.headers.get("Content-Type", "")
                    .split(";")[0]
                    .strip()
                    .lower()
                )
    except requests.RequestException:
        pass

    return None


def is_pdf_content_type(content_type: str | None) -> bool:
    """Check if the content type indicates a PDF."""
    if not content_type:
        return False
    return content_type in ("application/pdf", "application/x-pdf")


================================================
FILE: bookmarks/settings/__init__.py
================================================
# Use dev settings as default, use production if dev settings do not exist
# ruff: noqa
try:
    from .dev import *
except:
    from .prod import *


================================================
FILE: bookmarks/settings/base.py
================================================
"""
Django settings for linkding webapp.

Generated by 'django-admin startproject' using Django 2.2.2.

For more information on this file, see
https://docs.djangoproject.com/en/2.2/topics/settings/

For the full list of settings and their values, see
https://docs.djangoproject.com/en/2.2/ref/settings/
"""

import json
import os
import shlex

# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
# BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/2.2/howto/deployment/checklist/

# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = "kgq$h3@!!vbb6*nzfz(dbze=*)zsroqa8gvc0#1gx$3cd8z99^"

# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = False

ALLOWED_HOSTS = ["*"]

USE_X_FORWARDED_HOST = os.getenv("LD_USE_X_FORWARDED_HOST", False) in (
    True,
    "True",
    "true",
    "1",
)

# Application definition

INSTALLED_APPS = [
    "bookmarks.apps.BookmarksConfig",
    "django.contrib.admin",
    "django.contrib.auth",
    "django.contrib.contenttypes",
    "django.contrib.sessions",
    "django.contrib.messages",
    "django.contrib.staticfiles",
    "rest_framework",
    "rest_framework.authtoken",
    "huey.contrib.djhuey",
    "mozilla_django_oidc",
]

MIDDLEWARE = [
    "django.middleware.security.SecurityMiddleware",
    "django.contrib.sessions.middleware.SessionMiddleware",
    "django.middleware.common.CommonMiddleware",
    "django.middleware.csrf.CsrfViewMiddleware",
    "django.contrib.auth.middleware.AuthenticationMiddleware",
    "bookmarks.middlewares.LinkdingMiddleware",
    "django.contrib.messages.middleware.MessageMiddleware",
    "django.middleware.clickjacking.XFrameOptionsMiddleware",
    "django.middleware.locale.LocaleMiddleware",
]

ROOT_URLCONF = "bookmarks.urls"

TEMPLATES = [
    {
        "BACKEND": "django.template.backends.django.DjangoTemplates",
        "DIRS": [],
        "APP_DIRS": True,
        "OPTIONS": {
            "context_processors": [
                "django.template.context_processors.debug",
                "django.template.context_processors.request",
                "django.contrib.auth.context_processors.auth",
                "django.contrib.messages.context_processors.messages",
                "bookmarks.context_processors.toasts",
                "bookmarks.context_processors.app_version",
            ],
        },
    },
]

DEFAULT_AUTO_FIELD = "django.db.models.AutoField"

WSGI_APPLICATION = "bookmarks.wsgi.application"

# Password validation
# https://docs.djangoproject.com/en/2.2/ref/settings/#auth-password-validators

AUTH_PASSWORD_VALIDATORS = [
    {
        "NAME": "django.contrib.auth.password_validation.UserAttributeSimilarityValidator",
    },
    {
        "NAME": "django.contrib.auth.password_validation.MinimumLengthValidator",
    },
    {
        "NAME": "django.contrib.auth.password_validation.CommonPasswordValidator",
    },
    {
        "NAME": "django.contrib.auth.password_validation.NumericPasswordValidator",
    },
]

# Website context path.
LD_CONTEXT_PATH = os.getenv("LD_CONTEXT_PATH", "")

LOGIN_URL = "/" + LD_CONTEXT_PATH + "login"
LOGIN_REDIRECT_URL = "/" + LD_CONTEXT_PATH + "bookmarks"
LOGOUT_REDIRECT_URL = "/" + LD_CONTEXT_PATH + "login"

# Internationalization
# https://docs.djangoproject.com/en/2.2/topics/i18n/

LANGUAGE_CODE = "en-us"

TIME_ZONE = os.getenv("TZ", "UTC")

USE_I18N = True

USE_TZ = True

# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/2.2/howto/static-files/

STATIC_URL = "/" + LD_CONTEXT_PATH + "static/"

# Collect static files in static folder
STATIC_ROOT = os.path.join(BASE_DIR, "static")

# REST framework
REST_FRAMEWORK = {
    "DEFAULT_AUTHENTICATION_CLASSES": [
        "bookmarks.api.auth.LinkdingTokenAuthentication",
        "rest_framework.authentication.SessionAuthentication",
    ],
    "DEFAULT_PERMISSION_CLASSES": ["rest_framework.permissions.IsAuthenticated"],
    "DEFAULT_PAGINATION_CLASS": "rest_framework.pagination.LimitOffsetPagination",
    "PAGE_SIZE": 100,
}

# URL validation flag
LD_DISABLE_URL_VALIDATION = os.getenv("LD_DISABLE_URL_VALIDATION", False) in (
    True,
    "True",
    "true",
    "1",
)

# Background task enabled setting
LD_DISABLE_BACKGROUND_TASKS = os.getenv("LD_DISABLE_BACKGROUND_TASKS", False) in (
    True,
    "True",
    "true",
    "1",
)

# Huey task queue
HUEY = {
    "huey_class": "huey.SqliteHuey",
    "filename": os.path.join(BASE_DIR, "data", "tasks.sqlite3"),
    "immediate": False,
    "results": False,
    "store_none": False,
    "utc": True,
    "consumer": {
        "workers": 2,
        "worker_type": "thread",
        "initial_delay": 5,
        "backoff": 1.15,
        "max_delay": 10,
        "scheduler_interval": 10,
        "periodic": True,
        "check_worker_health": True,
        "health_check_interval": 10,
    },
}

# Disable login form if configured
LD_DISABLE_LOGIN_FORM = os.getenv("LD_DISABLE_LOGIN_FORM", False) in (
    True,
    "True",
    "true",
    "1",
)

# Enable OICD support if configured
LD_ENABLE_OIDC = os.getenv("LD_ENABLE_OIDC", False) in (True, "True", "true", "1")

AUTHENTICATION_BACKENDS = ["django.contrib.auth.backends.ModelBackend"]

if LD_ENABLE_OIDC:
    AUTHENTICATION_BACKENDS.append("mozilla_django_oidc.auth.OIDCAuthenticationBackend")

    OIDC_USERNAME_ALGO = "bookmarks.utils.generate_username"
    OIDC_OP_AUTHORIZATION_ENDPOINT = os.getenv("OIDC_OP_AUTHORIZATION_ENDPOINT")
    OIDC_OP_TOKEN_ENDPOINT = os.getenv("OIDC_OP_TOKEN_ENDPOINT")
    OIDC_OP_USER_ENDPOINT = os.getenv("OIDC_OP_USER_ENDPOINT")
    OIDC_OP_JWKS_ENDPOINT = os.getenv("OIDC_OP_JWKS_ENDPOINT")
    OIDC_RP_CLIENT_ID = os.getenv("OIDC_RP_CLIENT_ID")
    OIDC_RP_CLIENT_SECRET = os.getenv("OIDC_RP_CLIENT_SECRET")
    OIDC_RP_SIGN_ALGO = os.getenv("OIDC_RP_SIGN_ALGO", "RS256")
    OIDC_RP_SCOPES = os.getenv("OIDC_RP_SCOPES", "openid email profile")
    OIDC_USE_PKCE = os.getenv("OIDC_USE_PKCE", True) in (True, "True", "true", "1")
    OIDC_VERIFY_SSL = os.getenv("OIDC_VERIFY_SSL", True) in (True, "True", "true", "1")
    OIDC_USERNAME_CLAIM = os.getenv("OIDC_USERNAME_CLAIM", "email")

# Enable authentication proxy support if configured
LD_ENABLE_AUTH_PROXY = os.getenv("LD_ENABLE_AUTH_PROXY", False) in (
    True,
    "True",
    "true",
    "1",
)
LD_AUTH_PROXY_USERNAME_HEADER = os.getenv(
    "LD_AUTH_PROXY_USERNAME_HEADER", "REMOTE_USER"
)
LD_AUTH_PROXY_LOGOUT_URL = os.getenv("LD_AUTH_PROXY_LOGOUT_URL", None)

if LD_ENABLE_AUTH_PROXY:
    # Add middleware that automatically authenticates requests that have a known username
    # in the LD_AUTH_PROXY_USERNAME_HEADER request header
    MIDDLEWARE.append("bookmarks.middlewares.CustomRemoteUserMiddleware")
    # Configure auth backend that does not require a password credential
    AUTHENTICATION_BACKENDS = ["django.contrib.auth.backends.RemoteUserBackend"]
    # Configure logout URL
    if LD_AUTH_PROXY_LOGOUT_URL:
        LOGOUT_REDIRECT_URL = LD_AUTH_PROXY_LOGOUT_URL

# CSRF trusted origins
trusted_origins = os.getenv("LD_CSRF_TRUSTED_ORIGINS", "")
if trusted_origins:
    CSRF_TRUSTED_ORIGINS = trusted_origins.split(",")

# Database
# https://docs.djangoproject.com/en/2.2/ref/settings/#databases

LD_DB_ENGINE = os.getenv("LD_DB_ENGINE", "sqlite")
LD_DB_HOST = os.getenv("LD_DB_HOST", "localhost")
LD_DB_DATABASE = os.getenv("LD_DB_DATABASE", "linkding")
LD_DB_USER = os.getenv("LD_DB_USER", "linkding")
LD_DB_PASSWORD = os.getenv("LD_DB_PASSWORD", None)
LD_DB_PORT = os.getenv("LD_DB_PORT", None)
LD_DB_OPTIONS = json.loads(os.getenv("LD_DB_OPTIONS") or "{}")

if LD_DB_ENGINE == "postgres":
    default_database = {
        "ENGINE": "django.db.backends.postgresql_psycopg2",
        "NAME": LD_DB_DATABASE,
        "USER": LD_DB_USER,
        "PASSWORD": LD_DB_PASSWORD,
        "HOST": LD_DB_HOST,
        "PORT": LD_DB_PORT,
        "OPTIONS": LD_DB_OPTIONS,
    }
else:
    default_database = {
        "ENGINE": "django.db.backends.sqlite3",
        "NAME": os.path.join(BASE_DIR, "data", "db.sqlite3"),
        "OPTIONS": LD_DB_OPTIONS,
        # Creating a connection loads the ICU extension into the SQLite
        # connection, and also loads an ICU collation. The latter causes a
        # memory leak, so try to counter that by making connections indefinitely
        # persistent.
        "CONN_MAX_AGE": None,
    }

DATABASES = {"default": default_database}

SQLITE_ICU_EXTENSION_PATH = "./libicu.so"
USE_SQLITE = default_database["ENGINE"] == "django.db.backends.sqlite3"
USE_SQLITE_ICU_EXTENSION = USE_SQLITE and os.path.exists(SQLITE_ICU_EXTENSION_PATH)

# Favicons
LD_DEFAULT_FAVICON_PROVIDER = "https://t1.gstatic.com/faviconV2?client=SOCIAL&type=FAVICON&fallback_opts=TYPE,SIZE,URL&url={url}&size=32"
LD_FAVICON_PROVIDER = os.getenv("LD_FAVICON_PROVIDER", LD_DEFAULT_FAVICON_PROVIDER)
LD_FAVICON_FOLDER = os.path.join(BASE_DIR, "data", "favicons")
LD_ENABLE_REFRESH_FAVICONS = os.getenv("LD_ENABLE_REFRESH_FAVICONS", True) in (
    True,
    "True",
    "true",
    "1",
)

# Previews settings
LD_PREVIEW_FOLDER = os.path.join(BASE_DIR, "data", "previews")
LD_PREVIEW_MAX_SIZE = int(os.getenv("LD_PREVIEW_MAX_SIZE", 5242880))
LD_PREVIEW_ALLOWED_EXTENSIONS = [
    ".jpg",
    ".jpeg",
    ".png",
    ".gif",
    ".svg",
    ".webp",
]

# Asset / snapshot settings
LD_ASSET_FOLDER = os.path.join(BASE_DIR, "data", "assets")

LD_ENABLE_SNAPSHOTS = os.getenv("LD_ENABLE_SNAPSHOTS", False) in (
    True,
    "True",
    "true",
    "1",
)
LD_DISABLE_ASSET_UPLOAD = os.getenv("LD_DISABLE_ASSET_UPLOAD", False) in (
    True,
    "True",
    "true",
    "1",
)
LD_SINGLEFILE_PATH = os.getenv("LD_SINGLEFILE_PATH", "single-file")
LD_SINGLEFILE_UBLOCK_OPTIONS = os.getenv(
    "LD_SINGLEFILE_UBLOCK_OPTIONS",
    shlex.join(
        [
            '--browser-arg="--headless=new"',
            '--browser-arg="--user-data-dir=./chromium-profile"',
            '--browser-arg="--no-sandbox"',
            '--browser-arg="--load-extension=uBOLite.chromium.mv3"',
        ]
    ),
)
LD_SINGLEFILE_OPTIONS = os.getenv("LD_SINGLEFILE_OPTIONS", "")
LD_SINGLEFILE_TIMEOUT_SEC = float(os.getenv("LD_SINGLEFILE_TIMEOUT_SEC", 120))
LD_SNAPSHOT_PDF_MAX_SIZE = int(os.getenv("LD_SNAPSHOT_PDF_MAX_SIZE", 15728640))  # 15MB

# Monolith isn't used at the moment, as the local snapshot implementation
# switched to single-file after the prototype. Keeping this around in case
# it turns out to be useful in the future.
LD_MONOLITH_PATH = os.getenv("LD_MONOLITH_PATH", "monolith")
LD_MONOLITH_OPTIONS = os.getenv("LD_MONOLITH_OPTIONS", "-a -v -s")


================================================
FILE: bookmarks/settings/custom.py
================================================
# Placeholder, can be mounted in a Docker container with a custom settings


================================================
FILE: bookmarks/settings/dev.py
================================================
"""
Development settings for linkding webapp
"""

# ruff: noqa

# Start from development settings
# noinspection PyUnresolvedReferences
from .base import *

# Turn on debug mode
DEBUG = True

# Enable debug toolbar
# INSTALLED_APPS.append("debug_toolbar")
# MIDDLEWARE.append("debug_toolbar.middleware.DebugToolbarMiddleware")

INTERNAL_IPS = [
    "127.0.0.1",
]

# Allow access through ngrok
CSRF_TRUSTED_ORIGINS = ["https://*.ngrok-free.app"]

STATICFILES_DIRS = [
    # Resolve theme files from style source folder
    os.path.join(BASE_DIR, "bookmarks", "styles"),
    # Resolve downloaded files in dev environment
    os.path.join(BASE_DIR, "data", "favicons"),
    os.path.join(BASE_DIR, "data", "previews"),
]

# Enable debug logging
LOGGING = {
    "version": 1,
    "disable_existing_loggers": False,
    "formatters": {
        "simple": {
            "format": "{levelname} {asctime} {module}: {message}",
            "style": "{",
        },
    },
    "handlers": {"console": {"class": "logging.StreamHandler", "formatter": "simple"}},
    "root": {
        "handlers": ["console"],
        "level": "WARNING",
    },
    "loggers": {
        "django.db.backends": {
            "level": "ERROR",  # Set to DEBUG to log all SQL calls
            "handlers": ["console"],
        },
        "bookmarks": {  # Log importer debug output
            "level": "DEBUG",
            "handlers": ["console"],
            "propagate": False,
        },
        "huey": {  # Huey
            "level": "INFO",
            "handlers": ["console"],
            "propagate": False,
        },
    },
}

# Import custom settings
# noinspection PyUnresolvedReferences
from .custom import *


================================================
FILE: bookmarks/settings/prod.py
================================================
"""
Production settings for linkding webapp
"""

# ruff: noqa

# Start from development settings
# noinspection PyUnresolvedReferences
import os

from django.core.management.utils import get_random_secret_key
from .base import *

# Turn of debug mode
DEBUG = False

# Try read secret key from file
try:
    with open(os.path.join(BASE_DIR, "data", "secretkey.txt")) as f:
        SECRET_KEY = f.read().strip()
except:
    SECRET_KEY = get_random_secret_key()

# Set ALLOWED_HOSTS
# By default look in the HOST_NAME environment variable, if that is not set then allow all hosts
host_name = os.environ.get("HOST_NAME")
if host_name:
    ALLOWED_HOSTS = [host_name]
else:
    ALLOWED_HOSTS = ["*"]

# Logging
LOGGING = {
    "version": 1,
    "disable_existing_loggers": False,
    "formatters": {
        "simple": {
            "format": "{asctime} {levelname} {message}",
            "style": "{",
        },
    },
    "handlers": {"console": {"class": "logging.StreamHandler", "formatter": "simple"}},
    "root": {
        "handlers": ["console"],
        "level": "WARN",
    },
    "loggers": {
        "bookmarks": {
            "level": "INFO",
            "handlers": ["console"],
            "propagate": False,
        },
        "huey": {
            "level": "INFO",
            "handlers": ["console"],
            "propagate": False,
        },
    },
}

# Import custom settings
# noinspection PyUnresolvedReferences
from .custom import *


================================================
FILE: bookmarks/signals.py
================================================
from django.conf import settings
from django.db.backends.signals import connection_created
from django.dispatch import receiver


@receiver(connection_created)
def extend_sqlite(connection=None, **kwargs):
    # Load ICU extension into Sqlite connection to support case-insensitive
    # comparisons with unicode characters
    if connection.vendor == "sqlite" and settings.USE_SQLITE_ICU_EXTENSION:
        connection.connection.enable_load_extension(True)
        connection.connection.load_extension(
            settings.SQLITE_ICU_EXTENSION_PATH.rstrip(".so")
        )

        with connection.cursor() as cursor:
            # Load an ICU collation for case-insensitive ordering.
            # The first param can be a specific locale, it seems that not
            # providing one will use a default collation from the ICU project
            # that works reasonably for multiple languages
            cursor.execute("SELECT icu_load_collation('', 'ICU');")


================================================
FILE: bookmarks/static/live-reload.js
================================================
const RELOAD_URL = "/live_reload";

let eventSource = null;
let serverId = null;

function connect() {
  console.debug("[live-reload] Connecting to", RELOAD_URL);

  eventSource = new EventSource(RELOAD_URL);

  eventSource.addEventListener("connected", (event) => {
    const data = JSON.parse(event.data);

    if (serverId && serverId !== data.server_id) {
      console.log("[live-reload] Server restarted, reloading page");
      window.location.reload();
      return;
    }

    console.debug("[live-reload] Connected, server ID:", data.server_id);
    serverId = data.server_id;
  });

  eventSource.addEventListener("file_change", (event) => {
    const data = JSON.parse(event.data);
    console.log("[live-reload] File changed:", data);

    if (data.file_path.endsWith(".html") || data.file_path.endsWith(".css") || data.file_path.endsWith(".js")) {
      console.log("[live-reload] Asset changed, reloading page");
      window.location.reload();
    }
  });

  eventSource.onerror = (error) => {
    console.debug("[live-reload] Disconnected", error);
    eventSource.close();
    eventSource = null;

    // Reconnect after a delay
    setTimeout(connect, 1000);
  };
}

connect();


================================================
FILE: bookmarks/static/robots.txt
================================================
User-agent: *
Disallow: /


================================================
FILE: bookmarks/static/vendor/Readability.js
================================================
/*
 * Copyright (c) 2010 Arc90 Inc
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/*
 * This code is heavily based on Arc90's readability.js (1.7.1) script
 * available at: http://code.google.com/p/arc90labs-readability
 */

/**
 * Public constructor.
 * @param {HTMLDocument} doc     The document to parse.
 * @param {Object}       options The options object.
 */
function Readability(doc, options) {
  // In some older versions, people passed a URI as the first argument. Cope:
  if (options && options.documentElement) {
    doc = options;
    options = arguments[2];
  } else if (!doc || !doc.documentElement) {
    throw new Error("First argument to Readability constructor should be a document object.");
  }
  options = options || {};

  this._doc = doc;
  this._docJSDOMParser = this._doc.firstChild.__JSDOMParser__;
  this._articleTitle = null;
  this._articleByline = null;
  this._articleDir = null;
  this._articleSiteName = null;
  this._attempts = [];

  // Configurable options
  this._debug = !!options.debug;
  this._maxElemsToParse = options.maxElemsToParse || this.DEFAULT_MAX_ELEMS_TO_PARSE;
  this._nbTopCandidates = options.nbTopCandidates || this.DEFAULT_N_TOP_CANDIDATES;
  this._charThreshold = options.charThreshold || this.DEFAULT_CHAR_THRESHOLD;
  this._classesToPreserve = this.CLASSES_TO_PRESERVE.concat(options.classesToPreserve || []);
  this._keepClasses = !!options.keepClasses;
  this._serializer = options.serializer || function(el) {
    return el.innerHTML;
  };
  this._disableJSONLD = !!options.disableJSONLD;
  this._allowedVideoRegex = options.allowedVideoRegex || this.REGEXPS.videos;

  // Start with all flags set
  this._flags = this.FLAG_STRIP_UNLIKELYS |
                this.FLAG_WEIGHT_CLASSES |
                this.FLAG_CLEAN_CONDITIONALLY;


  // Control whether log messages are sent to the console
  if (this._debug) {
    let logNode = function(node) {
      if (node.nodeType == node.TEXT_NODE) {
        return `${node.nodeName} ("${node.textContent}")`;
      }
      let attrPairs = Array.from(node.attributes || [], function(attr) {
        return `${attr.name}="${attr.value}"`;
      }).join(" ");
      return `<${node.localName} ${attrPairs}>`;
    };
    this.log = function () {
      if (typeof console !== "undefined") {
        let args = Array.from(arguments, arg => {
          if (arg && arg.nodeType == this.ELEMENT_NODE) {
            return logNode(arg);
          }
          return arg;
        });
        args.unshift("Reader: (Readability)");
        console.log.apply(console, args);
      } else if (typeof dump !== "undefined") {
        /* global dump */
        var msg = Array.prototype.map.call(arguments, function(x) {
          return (x && x.nodeName) ? logNode(x) : x;
        }).join(" ");
        dump("Reader: (Readability) " + msg + "\n");
      }
    };
  } else {
    this.log = function () {};
  }
}

Readability.prototype = {
  FLAG_STRIP_UNLIKELYS: 0x1,
  FLAG_WEIGHT_CLASSES: 0x2,
  FLAG_CLEAN_CONDITIONALLY: 0x4,

  // https://developer.mozilla.org/en-US/docs/Web/API/Node/nodeType
  ELEMENT_NODE: 1,
  TEXT_NODE: 3,

  // Max number of nodes supported by this parser. Default: 0 (no limit)
  DEFAULT_MAX_ELEMS_TO_PARSE: 0,

  // The number of top candidates to consider when analysing how
  // tight the competition is among candidates.
  DEFAULT_N_TOP_CANDIDATES: 5,

  // Element tags to score by default.
  DEFAULT_TAGS_TO_SCORE: "section,h2,h3,h4,h5,h6,p,td,pre".toUpperCase().split(","),

  // The default number of chars an article must have in order to return a result
  DEFAULT_CHAR_THRESHOLD: 500,

  // All of the regular expressions in use within readability.
  // Defined up here so we don't instantiate them repeatedly in loops.
  REGEXPS: {
    // NOTE: These two regular expressions are duplicated in
    // Readability-readerable.js. Please keep both copies in sync.
    unlikelyCandidates: /-ad-|ai2html|banner|breadcrumbs|combx|comment|community|cover-wrap|disqus|extra|footer|gdpr|header|legends|menu|related|remark|replies|rss|shoutbox|sidebar|skyscraper|social|sponsor|supplemental|ad-break|agegate|pagination|pager|popup|yom-remote/i,
    okMaybeItsACandidate: /and|article|body|column|content|main|shadow/i,

    positive: /article|body|content|entry|hentry|h-entry|main|page|pagination|post|text|blog|story/i,
    negative: /-ad-|hidden|^hid$| hid$| hid |^hid |banner|combx|comment|com-|contact|foot|footer|footnote|gdpr|masthead|media|meta|outbrain|promo|related|scroll|share|shoutbox|sidebar|skyscraper|sponsor|shopping|tags|tool|widget/i,
    extraneous: /print|archive|comment|discuss|e[\-]?mail|share|reply|all|login|sign|single|utility/i,
    byline: /byline|author|dateline|writtenby|p-author/i,
    replaceFonts: /<(\/?)font[^>]*>/gi,
    normalize: /\s{2,}/g,
    videos: /\/\/(www\.)?((dailymotion|youtube|youtube-nocookie|player\.vimeo|v\.qq)\.com|(archive|upload\.wikimedia)\.org|player\.twitch\.tv)/i,
    shareElements: /(\b|_)(share|sharedaddy)(\b|_)/i,
    nextLink: /(next|weiter|continue|>([^\|]|$)|»([^\|]|$))/i,
    prevLink: /(prev|earl|old|new|<|«)/i,
    tokenize: /\W+/g,
    whitespace: /^\s*$/,
    hasContent: /\S$/,
    hashUrl: /^#.+/,
    srcsetUrl: /(\S+)(\s+[\d.]+[xw])?(\s*(?:,|$))/g,
    b64DataUrl: /^data:\s*([^\s;,]+)\s*;\s*base64\s*,/i,
    // Commas as used in Latin, Sindhi, Chinese and various other scripts.
    // see: https://en.wikipedia.org/wiki/Comma#Comma_variants
    commas: /\u002C|\u060C|\uFE50|\uFE10|\uFE11|\u2E41|\u2E34|\u2E32|\uFF0C/g,
    // See: https://schema.org/Article
    jsonLdArticleTypes: /^Article|AdvertiserContentArticle|NewsArticle|AnalysisNewsArticle|AskPublicNewsArticle|BackgroundNewsArticle|OpinionNewsArticle|ReportageNewsArticle|ReviewNewsArticle|Report|SatiricalArticle|ScholarlyArticle|MedicalScholarlyArticle|SocialMediaPosting|BlogPosting|LiveBlogPosting|DiscussionForumPosting|TechArticle|APIReference$/
  },

  UNLIKELY_ROLES: [ "menu", "menubar", "complementary", "navigation", "alert", "alertdialog", "dialog" ],

  DIV_TO_P_ELEMS: new Set([ "BLOCKQUOTE", "DL", "DIV", "IMG", "OL", "P", "PRE", "TABLE", "UL" ]),

  ALTER_TO_DIV_EXCEPTIONS: ["DIV", "ARTICLE", "SECTION", "P"],

  PRESENTATIONAL_ATTRIBUTES: [ "align", "background", "bgcolor", "border", "cellpadding", "cellspacing", "frame", "hspace", "rules", "style", "valign", "vspace" ],

  DEPRECATED_SIZE_ATTRIBUTE_ELEMS: [ "TABLE", "TH", "TD", "HR", "PRE" ],

  // The commented out elements qualify as phrasing content but tend to be
  // removed by readability when put into paragraphs, so we ignore them here.
  PHRASING_ELEMS: [
    // "CANVAS", "IFRAME", "SVG", "VIDEO",
    "ABBR", "AUDIO", "B", "BDO", "BR", "BUTTON", "CITE", "CODE", "DATA",
    "DATALIST", "DFN", "EM", "EMBED", "I", "IMG", "INPUT", "KBD", "LABEL",
    "MARK", "MATH", "METER", "NOSCRIPT", "OBJECT", "OUTPUT", "PROGRESS", "Q",
    "RUBY", "SAMP", "SCRIPT", "SELECT", "SMALL", "SPAN", "STRONG", "SUB",
    "SUP", "TEXTAREA", "TIME", "VAR", "WBR"
  ],

  // These are the classes that readability sets itself.
  CLASSES_TO_PRESERVE: [ "page" ],

  // These are the list of HTML entities that need to be escaped.
  HTML_ESCAPE_MAP: {
    "lt": "<",
    "gt": ">",
    "amp": "&",
    "quot": '"',
    "apos": "'",
  },

  /**
   * Run any post-process modifications to article content as necessary.
   *
   * @param Element
   * @return void
  **/
  _postProcessContent: function(articleContent) {
    // Readability cannot open relative uris so we convert them to absolute uris.
    this._fixRelativeUris(articleContent);

    this._simplifyNestedElements(articleContent);

    if (!this._keepClasses) {
      // Remove classes.
      this._cleanClasses(articleContent);
    }
  },

  /**
   * Iterates over a NodeList, calls `filterFn` for each node and removes node
   * if function returned `true`.
   *
   * If function is not passed, removes all the nodes in node list.
   *
   * @param NodeList nodeList The nodes to operate on
   * @param Function filterFn the function to use as a filter
   * @return void
   */
  _removeNodes: function(nodeList, filterFn) {
    // Avoid ever operating on live node lists.
    if (this._docJSDOMParser && nodeList._isLiveNodeList) {
      throw new Error("Do not pass live node lists to _removeNodes");
    }
    for (var i = nodeList.length - 1; i >= 0; i--) {
      var node = nodeList[i];
      var parentNode = node.parentNode;
      if (parentNode) {
        if (!filterFn || filterFn.call(this, node, i, nodeList)) {
          parentNode.removeChild(node);
        }
      }
    }
  },

  /**
   * Iterates over a NodeList, and calls _setNodeTag for each node.
   *
   * @param NodeList nodeList The nodes to operate on
   * @param String newTagName the new tag name to use
   * @return void
   */
  _replaceNodeTags: function(nodeList, newTagName) {
    // Avoid ever operating on live node lists.
    if (this._docJSDOMParser && nodeList._isLiveNodeList) {
      throw new Error("Do not pass live node lists to _replaceNodeTags");
    }
    for (const node of nodeList) {
      this._setNodeTag(node, newTagName);
    }
  },

  /**
   * Iterate over a NodeList, which doesn't natively fully implement the Array
   * interface.
   *
   * For convenience, the current object context is applied to the provided
   * iterate function.
   *
   * @param  NodeList nodeList The NodeList.
   * @param  Function fn       The iterate function.
   * @return void
   */
  _forEachNode: function(nodeList, fn) {
    Array.prototype.forEach.call(nodeList, fn, this);
  },

  /**
   * Iterate over a NodeList, and return the first node that passes
   * the supplied test function
   *
   * For convenience, the current object context is applied to the provided
   * test function.
   *
   * @param  NodeList nodeList The NodeList.
   * @param  Function fn       The test function.
   * @return void
   */
  _findNode: function(nodeList, fn) {
    return Array.prototype.find.call(nodeList, fn, this);
  },

  /**
   * Iterate over a NodeList, return true if any of the provided iterate
   * function calls returns true, false otherwise.
   *
   * For convenience, the current object context is applied to the
   * provided iterate function.
   *
   * @param  NodeList nodeList The NodeList.
   * @param  Function fn       The iterate function.
   * @return Boolean
   */
  _someNode: function(nodeList, fn) {
    return Array.prototype.some.call(nodeList, fn, this);
  },

  /**
   * Iterate over a NodeList, return true if all of the provided iterate
   * function calls return true, false otherwise.
   *
   * For convenience, the current object context is applied to the
   * provided iterate function.
   *
   * @param  NodeList nodeList The NodeList.
   * @param  Function fn       The iterate function.
   * @return Boolean
   */
  _everyNode: function(nodeList, fn) {
    return Array.prototype.every.call(nodeList, fn, this);
  },

  /**
   * Concat all nodelists passed as arguments.
   *
   * @return ...NodeList
   * @return Array
   */
  _concatNodeLists: function() {
    var slice = Array.prototype.slice;
    var args = slice.call(arguments);
    var nodeLists = args.map(function(list) {
      return slice.call(list);
    });
    return Array.prototype.concat.apply([], nodeLists);
  },

  _getAllNodesWithTag: function(node, tagNames) {
    if (node.querySelectorAll) {
      return node.querySelectorAll(tagNames.join(","));
    }
    return [].concat.apply([], tagNames.map(function(tag) {
      var collection = node.getElementsByTagName(tag);
      return Array.isArray(collection) ? collection : Array.from(collection);
    }));
  },

  /**
   * Removes the class="" attribute from every element in the given
   * subtree, except those that match CLASSES_TO_PRESERVE and
   * the classesToPreserve array from the options object.
   *
   * @param Element
   * @return void
   */
  _cleanClasses: function(node) {
    var classesToPreserve = this._classesToPreserve;
    var className = (node.getAttribute("class") || "")
      .split(/\s+/)
      .filter(function(cls) {
        return classesToPreserve.indexOf(cls) != -1;
      })
      .join(" ");

    if (className) {
      node.setAttribute("class", className);
    } else {
      node.removeAttribute("class");
    }

    for (node = node.firstElementChild; node; node = node.nextElementSibling) {
      this._cleanClasses(node);
    }
  },

  /**
   * Converts each <a> and <img> uri in the given element to an absolute URI,
   * ignoring #ref URIs.
   *
   * @param Element
   * @return void
   */
  _fixRelativeUris: function(articleContent) {
    var baseURI = this._doc.baseURI;
    var documentURI = this._doc.documentURI;
    function toAbsoluteURI(uri) {
      // Leave hash links alone if the base URI matches the document URI:
      if (baseURI == documentURI && uri.charAt(0) == "#") {
        return uri;
      }

      // Otherwise, resolve against base URI:
      try {
        return new URL(uri, baseURI).href;
      } catch (ex) {
        // Something went wrong, just return the original:
      }
      return uri;
    }

    var links = this._getAllNodesWithTag(articleContent, ["a"]);
    this._forEachNode(links, function(link) {
      var href = link.getAttribute("href");
      if (href) {
        // Remove links with javascript: URIs, since
        // they won't work after scripts have been removed from the page.
        if (href.indexOf("javascript:") === 0) {
          // if the link only contains simple text content, it can be converted to a text node
          if (link.childNodes.length === 1 && link.childNodes[0].nodeType === this.TEXT_NODE) {
            var text = this._doc.createTextNode(link.textContent);
            link.parentNode.replaceChild(text, link);
          } else {
            // if the link has multiple children, they should all be preserved
            var container = this._doc.createElement("span");
            while (link.firstChild) {
              container.appendChild(link.firstChild);
            }
            link.parentNode.replaceChild(container, link);
          }
        } else {
          link.setAttribute("href", toAbsoluteURI(href));
        }
      }
    });

    var medias = this._getAllNodesWithTag(articleContent, [
      "img", "picture", "figure", "video", "audio", "source"
    ]);

    this._forEachNode(medias, function(media) {
      var src = media.getAttribute("src");
      var poster = media.getAttribute("poster");
      var srcset = media.getAttribute("srcset");

      if (src) {
        media.setAttribute("src", toAbsoluteURI(src));
      }

      if (poster) {
        media.setAttribute("poster", toAbsoluteURI(poster));
      }

      if (srcset) {
        var newSrcset = srcset.replace(this.REGEXPS.srcsetUrl, function(_, p1, p2, p3) {
          return toAbsoluteURI(p1) + (p2 || "") + p3;
        });

        media.setAttribute("srcset", newSrcset);
      }
    });
  },

  _simplifyNestedElements: function(articleContent) {
    var node = articleContent;

    while (node) {
      if (node.parentNode && ["DIV", "SECTION"].includes(node.tagName) && !(node.id && node.id.startsWith("readability"))) {
        if (this._isElementWithoutContent(node)) {
          node = this._removeAndGetNext(node);
          continue;
        } else if (this._hasSingleTagInsideElement(node, "DIV") || this._hasSingleTagInsideElement(node, "SECTION")) {
          var child = node.children[0];
          for (var i = 0; i < node.attributes.length; i++) {
            child.setAttribute(node.attributes[i].name, node.attributes[i].value);
          }
          node.parentNode.replaceChild(child, node);
          node = child;
          continue;
        }
      }

      node = this._getNextNode(node);
    }
  },

  /**
   * Get the article title as an H1.
   *
   * @return string
   **/
  _getArticleTitle: function() {
    var doc = this._doc;
    var curTitle = "";
    var origTitle = "";

    try {
      curTitle = origTitle = doc.title.trim();

      // If they had an element with id "title" in their HTML
      if (typeof curTitle !== "string")
        curTitle = origTitle = this._getInnerText(doc.getElementsByTagName("title")[0]);
    } catch (e) {/* ignore exceptions setting the title. */}

    var titleHadHierarchicalSeparators = false;
    function wordCount(str) {
      return str.split(/\s+/).length;
    }

    // If there's a separator in the title, first remove the final part
    if ((/ [\|\-\\\/>»] /).test(curTitle)) {
      titleHadHierarchicalSeparators = / [\\\/>»] /.test(curTitle);
      curTitle = origTitle.replace(/(.*)[\|\-\\\/>»] .*/gi, "$1");

      // If the resulting title is too short (3 words or fewer), remove
      // the first part instead:
      if (wordCount(curTitle) < 3)
        curTitle = origTitle.replace(/[^\|\-\\\/>»]*[\|\-\\\/>»](.*)/gi, "$1");
    } else if (curTitle.indexOf(": ") !== -1) {
      // Check if we have an heading containing this exact string, so we
      // could assume it's the full title.
      var headings = this._concatNodeLists(
        doc.getElementsByTagName("h1"),
        doc.getElementsByTagName("h2")
      );
      var trimmedTitle = curTitle.trim();
      var match = this._someNode(headings, function(heading) {
        return heading.textContent.trim() === trimmedTitle;
      });

      // If we don't, let's extract the title out of the original title string.
      if (!match) {
        curTitle = origTitle.substring(origTitle.lastIndexOf(":") + 1);

        // If the title is now too short, try the first colon instead:
        if (wordCount(curTitle) < 3) {
          curTitle = origTitle.substring(origTitle.indexOf(":") + 1);
          // But if we have too many words before the colon there's something weird
          // with the titles and the H tags so let's just use the original title instead
        } else if (wordCount(origTitle.substr(0, origTitle.indexOf(":"))) > 5) {
          curTitle = origTitle;
        }
      }
    } else if (curTitle.length > 150 || curTitle.length < 15) {
      var hOnes = doc.getElementsByTagName("h1");

      if (hOnes.length === 1)
        curTitle = this._getInnerText(hOnes[0]);
    }

    curTitle = curTitle.trim().replace(this.REGEXPS.normalize, " ");
    // If we now have 4 words or fewer as our title, and either no
    // 'hierarchical' separators (\, /, > or ») were found in the original
    // title or we decreased the number of words by more than 1 word, use
    // the original title.
    var curTitleWordCount = wordCount(curTitle);
    if (curTitleWordCount <= 4 &&
        (!titleHadHierarchicalSeparators ||
         curTitleWordCount != wordCount(origTitle.replace(/[\|\-\\\/>»]+/g, "")) - 1)) {
      curTitle = origTitle;
    }

    return curTitle;
  },

  /**
   * Prepare the HTML document for readability to scrape it.
   * This includes things like stripping javascript, CSS, and handling terrible markup.
   *
   * @return void
   **/
  _prepDocument: function() {
    var doc = this._doc;

    // Remove all style tags in head
    this._removeNodes(this._getAllNodesWithTag(doc, ["style"]));

    if (doc.body) {
      this._replaceBrs(doc.body);
    }

    this._replaceNodeTags(this._getAllNodesWithTag(doc, ["font"]), "SPAN");
  },

  /**
   * Finds the next node, starting from the given node, and ignoring
   * whitespace in between. If the given node is an element, the same node is
   * returned.
   */
  _nextNode: function (node) {
    var next = node;
    while (next
        && (next.nodeType != this.ELEMENT_NODE)
        && this.REGEXPS.whitespace.test(next.textContent)) {
      next = next.nextSibling;
    }
    return next;
  },

  /**
   * Replaces 2 or more successive <br> elements with a single <p>.
   * Whitespace between <br> elements are ignored. For example:
   *   <div>foo<br>bar<br> <br><br>abc</div>
   * will become:
   *   <div>foo<br>bar<p>abc</p></div>
   */
  _replaceBrs: function (elem) {
    this._forEachNode(this._getAllNodesWithTag(elem, ["br"]), function(br) {
      var next = br.nextSibling;

      // Whether 2 or more <br> elements have been found and replaced with a
      // <p> block.
      var replaced = false;

      // If we find a <br> chain, remove the <br>s until we hit another node
      // or non-whitespace. This leaves behind the first <br> in the chain
      // (which will be replaced with a <p> later).
      while ((next = this._nextNode(next)) && (next.tagName == "BR")) {
        replaced = true;
        var brSibling = next.nextSibling;
        next.parentNode.removeChild(next);
        next = brSibling;
      }

      // If we removed a <br> chain, replace the remaining <br> with a <p>. Add
      // all sibling nodes as children of the <p> until we hit another <br>
      // chain.
      if (replaced) {
        var p = this._doc.createElement("p");
        br.parentNode.replaceChild(p, br);

        next = p.nextSibling;
        while (next) {
          // If we've hit another <br><br>, we're done adding children to this <p>.
          if (next.tagName == "BR") {
            var nextElem = this._nextNode(next.nextSibling);
            if (nextElem && nextElem.tagName == "BR")
              break;
          }

          if (!this._isPhrasingContent(next))
            break;

          // Otherwise, make this node a child of the new <p>.
          var sibling = next.nextSibling;
          p.appendChild(next);
          next = sibling;
        }

        while (p.lastChild && this._isWhitespace(p.lastChild)) {
          p.removeChild(p.lastChild);
        }

        if (p.parentNode.tagName === "P")
          this._setNodeTag(p.parentNode, "DIV");
      }
    });
  },

  _setNodeTag: function (node, tag) {
    this.log("_setNodeTag", node, tag);
    if (this._docJSDOMParser) {
      node.localName = tag.toLowerCase();
      node.tagName = tag.toUpperCase();
      return node;
    }

    var replacement = node.ownerDocument.createElement(tag);
    while (node.firstChild) {
      replacement.appendChild(node.firstChild);
    }
    node.parentNode.replaceChild(replacement, node);
    if (node.readability)
      replacement.readability = node.readability;

    for (var i = 0; i < node.attributes.length; i++) {
      try {
        replacement.setAttribute(node.attributes[i].name, node.attributes[i].value);
      } catch (ex) {
        /* it's possible for setAttribute() to throw if the attribute name
         * isn't a valid XML Name. Such attributes can however be parsed from
         * source in HTML docs, see https://github.com/whatwg/html/issues/4275,
         * so we can hit them here and then throw. We don't care about such
         * attributes so we ignore them.
         */
      }
    }
    return replacement;
  },

  /**
   * Prepare the article node for display. Clean out any inline styles,
   * iframes, forms, strip extraneous <p> tags, etc.
   *
   * @param Element
   * @return void
   **/
  _prepArticle: function(articleContent) {
    this._cleanStyles(articleContent);

    // Check for data tables before we continue, to avoid removing items in
    // those tables, which will often be isolated even though they're
    // visually linked to other content-ful elements (text, images, etc.).
    this._markDataTables(articleContent);

    this._fixLazyImages(articleContent);

    // Clean out junk from the article content
    this._cleanConditionally(articleContent, "form");
    this._cleanConditionally(articleContent, "fieldset");
    this._clean(articleContent, "object");
    this._clean(articleContent, "embed");
    this._clean(articleContent, "footer");
    this._clean(articleContent, "link");
    this._clean(articleContent, "aside");

    // Clean out elements with little content that have "share" in their id/class combinations from final top candidates,
    // which means we don't remove the top candidates even they have "share".

    var shareElementThreshold = this.DEFAULT_CHAR_THRESHOLD;

    this._forEachNode(articleContent.children, function (topCandidate) {
      this._cleanMatchedNodes(topCandidate, function (node, matchString) {
        return this.REGEXPS.shareElements.test(matchString) && node.textContent.length < shareElementThreshold;
      });
    });

    this._clean(articleContent, "iframe");
    this._clean(articleContent, "input");
    this._clean(articleContent, "textarea");
    this._clean(articleContent, "select");
    this._clean(articleContent, "button");
    this._cleanHeaders(articleContent);

    // Do these last as the previous stuff may have removed junk
    // that will affect these
    this._cleanConditionally(articleContent, "table");
    this._cleanConditionally(articleContent, "ul");
    this._cleanConditionally(articleContent, "div");

    // replace H1 with H2 as H1 should be only title that is displayed separately
    this._replaceNodeTags(this._getAllNodesWithTag(articleContent, ["h1"]), "h2");

    // Remove extra paragraphs
    this._removeNodes(this._getAllNodesWithTag(articleContent, ["p"]), function (paragraph) {
      var imgCount = paragraph.getElementsByTagName("img").length;
      var embedCount = paragraph.getElementsByTagName("embed").length;
      var objectCount = paragraph.getElementsByTagName("object").length;
      // At this point, nasty iframes have been removed, only remain embedded video ones.
      var iframeCount = paragraph.getElementsByTagName("iframe").length;
      var totalCount = imgCount + embedCount + objectCount + iframeCount;

      return totalCount === 0 && !this._getInnerText(paragraph, false);
    });

    this._forEachNode(this._getAllNodesWithTag(articleContent, ["br"]), function(br) {
      var next = this._nextNode(br.nextSibling);
      if (next && next.tagName == "P")
        br.parentNode.removeChild(br);
    });

    // Remove single-cell tables
    this._forEachNode(this._getAllNodesWithTag(articleContent, ["table"]), function(table) {
      var tbody = this._hasSingleTagInsideElement(table, "TBODY") ? table.firstElementChild : table;
      if (this._hasSingleTagInsideElement(tbody, "TR")) {
        var row = tbody.firstElementChild;
        if (this._hasSingleTagInsideElement(row, "TD")) {
          var cell = row.firstElementChild;
          cell = this._setNodeTag(cell, this._everyNode(cell.childNodes, this._isPhrasingContent) ? "P" : "DIV");
          table.parentNode.replaceChild(cell, table);
        }
      }
    });
  },

  /**
   * Initialize a node with the readability object. Also checks the
   * className/id for special names to add to its score.
   *
   * @param Element
   * @return void
  **/
  _initializeNode: function(node) {
    node.readability = {"contentScore": 0};

    switch (node.tagName) {
      case "DIV":
        node.readability.contentScore += 5;
        break;

      case "PRE":
      case "TD":
      case "BLOCKQUOTE":
        node.readability.contentScore += 3;
        break;

      case "ADDRESS":
      case "OL":
      case "UL":
      case "DL":
      case "DD":
      case "DT":
      case "LI":
      case "FORM":
        node.readability.contentScore -= 3;
        break;

      case "H1":
      case "H2":
      case "H3":
      case "H4":
      case "H5":
      case "H6":
      case "TH":
        node.readability.contentScore -= 5;
        break;
    }

    node.readability.contentScore += this._getClassWeight(node);
  },

  _removeAndGetNext: function(node) {
    var nextNode = this._getNextNode(node, true);
    node.parentNode.removeChild(node);
    return nextNode;
  },

  /**
   * Traverse the DOM from node to node, starting at the node passed in.
   * Pass true for the second parameter to indicate this node itself
   * (and its kids) are going away, and we want the next node over.
   *
   * Calling this in a loop will traverse the DOM depth-first.
   */
  _getNextNode: function(node, ignoreSelfAndKids) {
    // First check for kids if those aren't being ignored
    if (!ignoreSelfAndKids && node.firstElementChild) {
      return node.firstElementChild;
    }
    // Then for siblings...
    if (node.nextElementSibling) {
      return node.nextElementSibling;
    }
    // And finally, move up the parent chain *and* find a sibling
    // (because this is depth-first traversal, we will have already
    // seen the parent nodes themselves).
    do {
      node = node.parentNode;
    } while (node && !node.nextElementSibling);
    return node && node.nextElementSibling;
  },

  // compares second text to first one
  // 1 = same text, 0 = completely different text
  // works the way that it splits both texts into words and then finds words that are unique in second text
  // the result is given by the lower length of unique parts
  _textSimilarity: function(textA, textB) {
    var tokensA = textA.toLowerCase().split(this.REGEXPS.tokenize).filter(Boolean);
    var tokensB = textB.toLowerCase().split(this.REGEXPS.tokenize).filter(Boolean);
    if (!tokensA.length || !tokensB.length) {
      return 0;
    }
    var uniqTokensB = tokensB.filter(token => !tokensA.includes(token));
    var distanceB = uniqTokensB.join(" ").length / tokensB.join(" ").length;
    return 1 - distanceB;
  },

  _checkByline: function(node, matchString) {
    if (this._articleByline) {
      return false;
    }

    if (node.getAttribute !== undefined) {
      var rel = node.getAttribute("rel");
      var itemprop = node.getAttribute("itemprop");
    }

    if ((rel === "author" || (itemprop && itemprop.indexOf("author") !== -1) || this.REGEXPS.byline.test(matchString)) && this._isValidByline(node.textContent)) {
      this._articleByline = node.textContent.trim();
      return true;
    }

    return false;
  },

  _getNodeAncestors: function(node, maxDepth) {
    maxDepth = maxDepth || 0;
    var i = 0, ancestors = [];
    while (node.parentNode) {
      ancestors.push(node.parentNode);
      if (maxDepth && ++i === maxDepth)
        break;
      node = node.parentNode;
    }
    return ancestors;
  },

  /***
   * grabArticle - Using a variety of metrics (content score, classname, element types), find the content that is
   *         most likely to be the stuff a user wants to read. Then return it wrapped up in a div.
   *
   * @param page a document to run upon. Needs to be a full document, complete with body.
   * @return Element
  **/
  _grabArticle: function (page) {
    this.log("**** grabArticle ****");
    var doc = this._doc;
    var isPaging = page !== null;
    page = page ? page : this._doc.body;

    // We can't grab an article if we don't have a page!
    if (!page) {
      this.log("No body found in document. Abort.");
      return null;
    }

    var pageCacheHtml = page.innerHTML;

    while (true) {
      this.log("Starting grabArticle loop");
      var stripUnlikelyCandidates = this._flagIsActive(this.FLAG_STRIP_UNLIKELYS);

      // First, node prepping. Trash nodes that look cruddy (like ones with the
      // class name "comment", etc), and turn divs into P tags where they have been
      // used inappropriately (as in, where they contain no other block level elements.)
      var elementsToScore = [];
      var node = this._doc.documentElement;

      let shouldRemoveTitleHeader = true;

      while (node) {

        if (node.tagName === "HTML") {
          this._articleLang = node.getAttribute("lang");
        }

        var matchString = node.className + " " + node.id;

        if (!this._isProbablyVisible(node)) {
          this.log("Removing hidden node - " + matchString);
          node = this._removeAndGetNext(node);
          continue;
        }

        // User is not able to see elements applied with both "aria-modal = true" and "role = dialog"
        if (node.getAttribute("aria-modal") == "true" && node.getAttribute("role") == "dialog") {
          node = this._removeAndGetNext(node);
          continue;
        }

        // Check to see if this node is a byline, and remove it if it is.
        if (this._checkByline(node, matchString)) {
          node = this._removeAndGetNext(node);
          continue;
        }

        if (shouldRemoveTitleHeader && this._headerDuplicatesTitle(node)) {
          this.log("Removing header: ", node.textContent.trim(), this._articleTitle.trim());
          shouldRemoveTitleHeader = false;
          node = this._removeAndGetNext(node);
          continue;
        }

        // Remove unlikely candidates
        if (stripUnlikelyCandidates) {
          if (this.REGEXPS.unlikelyCandidates.test(matchString) &&
              !this.REGEXPS.okMaybeItsACandidate.test(matchString) &&
              !this._hasAncestorTag(node, "table") &&
              !this._hasAncestorTag(node, "code") &&
              node.tagName !== "BODY" &&
              node.tagName !== "A") {
            this.log("Removing unlikely candidate - " + matchString);
            node = this._removeAndGetNext(node);
            continue;
          }

          if (this.UNLIKELY_ROLES.includes(node.getAttribute("role"))) {
            this.log("Removing content with role " + node.getAttribute("role") + " - " + matchString);
            node = this._removeAndGetNext(node);
            continue;
          }
        }

        // Remove DIV, SECTION, and HEADER nodes without any content(e.g. text, image, video, or iframe).
        if ((node.tagName === "DIV" || node.tagName === "SECTION" || node.tagName === "HEADER" ||
             node.tagName === "H1" || node.tagName === "H2" || node.tagName === "H3" ||
             node.tagName === "H4" || node.tagName === "H5" || node.tagName === "H6") &&
            this._isElementWithoutContent(node)) {
          node = this._removeAndGetNext(node);
          continue;
        }

        if (this.DEFAULT_TAGS_TO_SCORE.indexOf(node.tagName) !== -1) {
          elementsToScore.push(node);
        }

        // Turn all divs that don't have children block level elements into p's
        if (node.tagName === "DIV") {
          // Put phrasing content into paragraphs.
          var p = null;
          var childNode = node.firstChild;
          while (childNode) {
            var nextSibling = childNode.nextSibling;
            if (this._isPhrasingContent(childNode)) {
              if (p !== null) {
                p.appendChild(childNode);
              } else if (!this._isWhitespace(childNode)) {
                p = doc.createElement("p");
                node.replaceChild(p, childNode);
                p.appendChild(childNode);
              }
            } else if (p !== null) {
              while (p.lastChild && this._isWhitespace(p.lastChild)) {
                p.removeChild(p.lastChild);
              }
              p = null;
            }
            childNode = nextSibling;
          }

          // Sites like http://mobile.slate.com encloses each paragraph with a DIV
          // element. DIVs with only a P element inside and no text content can be
          // safely converted into plain P elements to avoid confusing the scoring
          // algorithm with DIVs with are, in practice, paragraphs.
          if (this._hasSingleTagInsideElement(node, "P") && this._getLinkDensity(node) < 0.25) {
            var newNode = node.children[0];
            node.parentNode.replaceChild(newNode, node);
            node = newNode;
            elementsToScore.push(node);
          } else if (!this._hasChildBlockElement(node)) {
            node = this._setNodeTag(node, "P");
            elementsToScore.push(node);
          }
        }
        node = this._getNextNode(node);
      }

      /**
       * Loop through all paragraphs, and assign a score to them based on how content-y they look.
       * Then add their score to their parent node.
       *
       * A score is determined by things like number of commas, class names, etc. Maybe eventually link density.
      **/
      var candidates = [];
      this._forEachNode(elementsToScore, function(elementToScore) {
        if (!elementToScore.parentNode || typeof(elementToScore.parentNode.tagName) === "undefined")
          return;

        // If this paragraph is less than 25 characters, don't even count it.
        var innerText = this._getInnerText(elementToScore);
        if (innerText.length < 25)
          return;

        // Exclude nodes with no ancestor.
        var ancestors = this._getNodeAncestors(elementToScore, 5);
        if (ancestors.length === 0)
          return;

        var contentScore = 0;

        // Add a point for the paragraph itself as a base.
        contentScore += 1;

        // Add points for any commas within this paragraph.
        contentScore += innerText.split(this.REGEXPS.commas).length;

        // For every 100 characters in this paragraph, add another point. Up to 3 points.
        contentScore += Math.min(Math.floor(innerText.length / 100), 3);

        // Initialize and score ancestors.
        this._forEachNode(ancestors, function(ancestor, level) {
          if (!ancestor.tagName || !ancestor.parentNode || typeof(ancestor.parentNode.tagName) === "undefined")
            return;

          if (typeof(ancestor.readability) === "undefined") {
            this._initializeNode(ancestor);
            candidates.push(ancestor);
          }

          // Node score divider:
          // - parent:             1 (no division)
          // - grandparent:        2
          // - great grandparent+: ancestor level * 3
          if (level === 0)
            var scoreDivider = 1;
          else if (level === 1)
            scoreDivider = 2;
          else
            scoreDivider = level * 3;
          ancestor.readability.contentScore += contentScore / scoreDivider;
        });
      });

      // After we've calculated scores, loop through all of the possible
      // candidate nodes we found and find the one with the highest score.
      var topCandidates = [];
      for (var c = 0, cl = candidates.length; c < cl; c += 1) {
        var candidate = candidates[c];

        // Scale the final candidates score based on link density. Good content
        // should have a relatively small link density (5% or less) and be mostly
        // unaffected by this operation.
        var candidateScore = candidate.readability.contentScore * (1 - this._getLinkDensity(candidate));
        candidate.readability.contentScore = candidateScore;

        this.log("Candidate:", candidate, "with score " + candidateScore);

        for (var t = 0; t < this._nbTopCandidates; t++) {
          var aTopCandidate = topCandidates[t];

          if (!aTopCandidate || candidateScore > aTopCandidate.readability.contentScore) {
            topCandidates.splice(t, 0, candidate);
            if (topCandidates.length > this._nbTopCandidates)
              topCandidates.pop();
            break;
          }
        }
      }

      var topCandidate = topCandidates[0] || null;
      var neededToCreateTopCandidate = false;
      var parentOfTopCandidate;

      // If we still have no top candidate, just use the body as a last resort.
      // We also have to copy the body node so it is something we can modify.
      if (topCandidate === null || topCandidate.tagName === "BODY") {
        // Move all of the page's children into topCandidate
        topCandidate = doc.createElement("DIV");
        neededToCreateTopCandidate = true;
        // Move everything (not just elements, also text nodes etc.) into the container
        // so we even include text directly in the body:
        while (page.firstChild) {
          this.log("Moving child out:", page.firstChild);
          topCandidate.appendChild(page.firstChild);
        }

        page.appendChild(topCandidate);

        this._initializeNode(topCandidate);
      } else if (topCandidate) {
        // Find a better top candidate node if it contains (at least three) nodes which belong to `topCandidates` array
        // and whose scores are quite closed with current `topCandidate` node.
        var alternativeCandidateAncestors = [];
        for (var i = 1; i < topCandidates.length; i++) {
          if (topCandidates[i].readability.contentScore / topCandidate.readability.contentScore >= 0.75) {
            alternativeCandidateAncestors.push(this._getNodeAncestors(topCandidates[i]));
          }
        }
        var MINIMUM_TOPCANDIDATES = 3;
        if (alternativeCandidateAncestors.length >= MINIMUM_TOPCANDIDATES) {
          parentOfTopCandidate = topCandidate.parentNode;
          while (parentOfTopCandidate.tagName !== "BODY") {
            var listsContainingThisAncestor = 0;
            for (var ancestorIndex = 0; ancestorIndex < alternativeCandidateAncestors.length && listsContainingThisAncestor < MINIMUM_TOPCANDIDATES; ancestorIndex++) {
              listsContainingThisAncestor += Number(alternativeCandidateAncestors[ancestorIndex].includes(parentOfTopCandidate));
            }
            if (listsContainingThisAncestor >= MINIMUM_TOPCANDIDATES) {
              topCandidate = parentOfTopCandidate;
              break;
            }
            parentOfTopCandidate = parentOfTopCandidate.parentNode;
          }
        }
        if (!topCandidate.readability) {
          this._initializeNode(topCandidate);
        }

        // Because of our bonus system, parents of candidates might have scores
        // themselves. They get half of the node. There won't be nodes with higher
        // scores than our topCandidate, but if we see the score going *up* in the first
        // few steps up the tree, that's a decent sign that there might be more content
        // lurking in other places that we want to unify in. The sibling stuff
        // below does some of that - but only if we've looked high enough up the DOM
        // tree.
        parentOfTopCandidate = topCandidate.parentNode;
        var lastScore = topCandidate.readability.contentScore;
        // The scores shouldn't get too low.
        var scoreThreshold = lastScore / 3;
        while (parentOfTopCandidate.tagName !== "BODY") {
          if (!parentOfTopCandidate.readability) {
            parentOfTopCandidate = parentOfTopCandidate.parentNode;
            continue;
          }
          var parentScore = parentOfTopCandidate.readability.contentScore;
          if (parentScore < scoreThreshold)
            break;
          if (parentScore > lastScore) {
            // Alright! We found a better parent to use.
            topCandidate = parentOfTopCandidate;
            break;
          }
          lastScore = parentOfTopCandidate.readability.contentScore;
          parentOfTopCandidate = parentOfTopCandidate.parentNode;
        }

        // If the top candidate is the only child, use parent instead. This will help sibling
        // joining logic when adjacent content is actually located in parent's sibling node.
        parentOfTopCandidate = topCandidate.parentNode;
        while (parentOfTopCandidate.tagName != "BODY" && parentOfTopCandidate.children.length == 1) {
          topCandidate = parentOfTopCandidate;
          parentOfTopCandidate = topCandidate.parentNode;
        }
        if (!topCandidate.readability) {
          this._initializeNode(topCandidate);
        }
      }

      // Now that we have the top candidate, look through its siblings for content
      // that might also be related. Things like preambles, content split by ads
      // that we removed, etc.
      var articleContent = doc.createElement("DIV");
      if (isPaging)
        articleContent.id = "readability-content";

      var siblingScoreThreshold = Math.max(10, topCandidate.readability.contentScore * 0.2);
      // Keep potential top candidate's parent node to try to get text direction of it later.
      parentOfTopCandidate = topCandidate.parentNode;
      var siblings = parentOfTopCandidate.children;

      for (var s = 0, sl = siblings.length; s < sl; s++) {
        var sibling = siblings[s];
        var append = false;

        this.log("Looking at sibling node:", sibling, sibling.readability ? ("with score " + sibling.readability.contentScore) : "");
        this.log("Sibling has score", sibling.readability ? sibling.readability.contentScore : "Unknown");

        if (sibling === topCandidate) {
          append = true;
        } else {
          var contentBonus = 0;

          // Give a bonus if sibling nodes and top candidates have the example same classname
          if (sibling.className === topCandidate.className && topCandidate.className !== "")
            contentBonus += topCandidate.readability.contentScore * 0.2;

          if (sibling.readability &&
              ((sibling.readability.contentScore + contentBonus) >= siblingScoreThreshold)) {
            append = true;
          } else if (sibling.nodeName === "P") {
            var linkDensity = this._getLinkDensity(sibling);
            var nodeContent = this._getInnerText(sibling);
            var nodeLength = nodeContent.length;

            if (nodeLength > 80 && linkDensity < 0.25) {
              append = true;
            } else if (nodeLength < 80 && nodeLength > 0 && linkDensity === 0 &&
                       nodeContent.search(/\.( |$)/) !== -1) {
              append = true;
            }
          }
        }

        if (append) {
          this.log("Appending node:", sibling);

          if (this.ALTER_TO_DIV_EXCEPTIONS.indexOf(sibling.nodeName) === -1) {
            // We have a node that isn't a common block level element, like a form or td tag.
            // Turn it into a div so it doesn't get filtered out later by accident.
            this.log("Altering sibling:", sibling, "to div.");

            sibling = this._setNodeTag(sibling, "DIV");
          }

          articleContent.appendChild(sibling);
          // Fetch children again to make it compatible
          // with DOM parsers without live collection support.
          siblings = parentOfTopCandidate.children;
          // siblings is a reference to the children array, and
          // sibling is removed from the array when we call appendChild().
          // As a result, we must revisit this index since the nodes
          // have been shifted.
          s -= 1;
          sl -= 1;
        }
      }

      if (this._debug)
        this.log("Article content pre-prep: " + articleContent.innerHTML);
      // So we have all of the content that we need. Now we clean it up for presentation.
      this._prepArticle(articleContent);
      if (this._debug)
        this.log("Article content post-prep: " + articleContent.innerHTML);

      if (neededToCreateTopCandidate) {
        // We already created a fake div thing, and there wouldn't have been any siblings left
        // for the previous loop, so there's no point trying to create a new div, and then
        // move all the children over. Just assign IDs and class names here. No need to append
        // because that already happened anyway.
        topCandidate.id = "readability-page-1";
        topCandidate.className = "page";
      } else {
        var div = doc.createElement("DIV");
        div.id = "readability-page-1";
        div.className = "page";
        while (articleContent.firstChild) {
          div.appendChild(articleContent.firstChild);
        }
        articleContent.appendChild(div);
      }

      if (this._debug)
        this.log("Article content after paging: " + articleContent.innerHTML);

      var parseSuccessful = true;

      // Now that we've gone through the full algorithm, check to see if
      // we got any meaningful content. If we didn't, we may need to re-run
      // grabArticle with different flags set. This gives us a higher likelihood of
      // finding the content, and the sieve approach gives us a higher likelihood of
      // finding the -right- content.
      var textLength = this._getInnerText(articleContent, true).length;
      if (textLength < this._charThreshold) {
        parseSuccessful = false;
        page.innerHTML = pageCacheHtml;

        if (this._flagIsActive(this.FLAG_STRIP_UNLIKELYS)) {
          this._removeFlag(this.FLAG_STRIP_UNLIKELYS);
          this._attempts.push({articleContent: articleContent, textLength: textLength});
        } else if (this._flagIsActive(this.FLAG_WEIGHT_CLASSES)) {
          this._removeFlag(this.FLAG_WEIGHT_CLASSES);
          this._attempts.push({articleContent: articleContent, textLength: textLength});
        } else if (this._flagIsActive(this.FLAG_CLEAN_CONDITIONALLY)) {
          this._removeFlag(this.FLAG_CLEAN_CONDITIONALLY);
          this._attempts.push({articleContent: articleContent, textLength: textLength});
        } else {
          this._attempts.push({articleContent: articleContent, textLength: textLength});
          // No luck after removing flags, just return the longest text we found during the different loops
          this._attempts.sort(function (a, b) {
            return b.textLength - a.textLength;
          });

          // But first check if we actually have something
          if (!this._attempts[0].textLength) {
            return null;
          }

          articleContent = this._attempts[0].articleContent;
          parseSuccessful = true;
        }
      }

      if (parseSuccessful) {
        // Find out text direction from ancestors of final top candidate.
        var ancestors = [parentOfTopCandidate, topCandidate].concat(this._getNodeAncestors(parentOfTopCandidate));
        this._someNode(ancestors, function(ancestor) {
          if (!ancestor.tagName)
            return false;
          var articleDir = ancestor.getAttribute("dir");
          if (articleDir) {
            this._articleDir = articleDir;
            return true;
          }
          return false;
        });
        return articleContent;
      }
    }
  },

  /**
   * Check whether the input string could be a byline.
   * This verifies that the input is a string, and that the length
   * is less than 100 chars.
   *
   * @param possibleByline {string} - a string to check whether its a byline.
   * @return Boolean - whether the input string is a byline.
   */
  _isValidByline: function(byline) {
    if (typeof byline == "string" || byline instanceof String) {
      byline = byline.trim();
      return (byline.length > 0) && (byline.length < 100);
    }
    return false;
  },

  /**
   * Converts some of the common HTML entities in string to their corresponding characters.
   *
   * @param str {string} - a string to unescape.
   * @return string without HTML entity.
   */
  _unescapeHtmlEntities: function(str) {
    if (!str) {
      return str;
    }

    var htmlEscapeMap = this.HTML_ESCAPE_MAP;
    return str.replace(/&(quot|amp|apos|lt|gt);/g, function(_, tag) {
      return htmlEscapeMap[tag];
    }).replace(/&#(?:x([0-9a-z]{1,4})|([0-9]{1,4}));/gi, function(_, hex, numStr) {
      var num = parseInt(hex || numStr, hex ? 16 : 10);
      return String.fromCharCode(num);
    });
  },

  /**
   * Try to extract metadata from JSON-LD object.
   * For now, only Schema.org objects of type Article or its subtypes are supported.
   * @return Object with any metadata that could be extracted (possibly none)
   */
  _getJSONLD: function (doc) {
    var scripts = this._getAllNodesWithTag(doc, ["script"]);

    var metadata;

    this._forEachNode(scripts, function(jsonLdElement) {
      if (!metadata && jsonLdElement.getAttribute("type") === "application/ld+json") {
        try {
          // Strip CDATA markers if present
          var content = jsonLdElement.textContent.replace(/^\s*<!\[CDATA\[|\]\]>\s*$/g, "");
          var parsed = JSON.parse(content);
          if (
            !parsed["@context"] ||
            !parsed["@context"].match(/^https?\:\/\/schema\.org$/)
          ) {
            return;
          }

          if (!parsed["@type"] && Array.isArray(parsed["@graph"])) {
            parsed = parsed["@graph"].find(function(it) {
              return (it["@type"] || "").match(
                this.REGEXPS.jsonLdArticleTypes
              );
            });
          }

          if (
            !parsed ||
            !parsed["@type"] ||
            !parsed["@type"].match(this.REGEXPS.jsonLdArticleTypes)
          ) {
            return;
          }

          metadata = {};

          if (typeof parsed.name === "string" && typeof parsed.headline === "string" && parsed.name !== parsed.headline) {
            // we have both name and headline element in the JSON-LD. They should both be the same but some websites like aktualne.cz
            // put their own name into "name" and the article title to "headline" which confuses Readability. So we try to check if either
            // "name" or "headline" closely matches the html title, and if so, use that one. If not, then we use "name" by default.

            var title = this._getArticleTitle();
            var nameMatches = this._textSimilarity(parsed.name, title) > 0.75;
            var headlineMatches = this._textSimilarity(parsed.headline, title) > 0.75;

            if (headlineMatches && !nameMatches) {
              metadata.title = parsed.headline;
            } else {
              metadata.title = parsed.name;
            }
          } else if (typeof parsed.name === "string") {
            metadata.title = parsed.name.trim();
          } else if (typeof parsed.headline === "string") {
            metadata.title = parsed.headline.trim();
          }
          if (parsed.author) {
            if (typeof parsed.author.name === "string") {
              metadata.byline = parsed.author.name.trim();
            } else if (Array.isArray(parsed.author) && parsed.author[0] && typeof parsed.author[0].name === "string") {
              metadata.byline = parsed.author
                .filter(function(author) {
                  return author && typeof author.name === "string";
                })
                .map(function(author) {
                  return author.name.trim();
                })
                .join(", ");
            }
          }
          if (typeof parsed.description === "string") {
            metadata.excerpt = parsed.description.trim();
          }
          if (
            parsed.publisher &&
            typeof parsed.publisher.name === "string"
          ) {
            metadata.siteName = parsed.publisher.name.trim();
          }
          if (typeof parsed.datePublished === "string") {
            metadata.datePublished = parsed.datePublished.trim();
          }
          return;
        } catch (err) {
          this.log(err.message);
        }
      }
    });
    return metadata ? metadata : {};
  },

  /**
   * Attempts to get excerpt and byline metadata for the article.
   *
   * @param {Object} jsonld — object containing any metadata that
   * could be extracted from JSON-LD object.
   *
   * @return Object with optional "excerpt" and "byline" properties
   */
  _getArticleMetadata: function(jsonld) {
    var metadata = {};
    var values = {};
    var metaElements = this._doc.getElementsByTagName("meta");

    // property is a space-separated list of values
    var propertyPattern = /\s*(article|dc|dcterm|og|twitter)\s*:\s*(author|creator|description|published_time|title|site_name)\s*/gi;

    // name is a single value
    var namePattern = /^\s*(?:(dc|dcterm|og|twitter|weibo:(article|webpage))\s*[\.:]\s*)?(author|creator|description|title|site_name)\s*$/i;

    // Find description tags.
    this._forEachNode(metaElements, function(element) {
      var elementName = element.getAttribute("name");
      var elementProperty = element.getAttribute("property");
      var content = element.getAttribute("content");
      if (!content) {
        return;
      }
      var matches = null;
      var name = null;

      if (elementProperty) {
        matches = elementProperty.match(propertyPattern);
        if (matches) {
          // Convert to lowercase, and remove any whitespace
          // so we can match below.
          name = matches[0].toLowerCase().replace(/\s/g, "");
          // multiple authors
          values[name] = content.trim();
        }
      }
      if (!matches && elementName && namePattern.test(elementName)) {
        name = elementName;
        if (content) {
          // Convert to lowercase, remove any whitespace, and convert dots
          // to colons so we can match below.
          name = name.toLowerCase().replace(/\s/g, "").replace(/\./g, ":");
          values[name] = content.trim();
        }
      }
    });

    // get title
    metadata.title = jsonld.title ||
                     values["dc:title"] ||
                     values["dcterm:title"] ||
                     values["og:title"] ||
                     values["weibo:article:title"] ||
                     values["weibo:webpage:title"] ||
                     values["title"] ||
                     values["twitter:title"];

    if (!metadata.title) {
      metadata.title = this._getArticleTitle();
    }

    // get author
    metadata.byline = jsonld.byline ||
                      values["dc:creator"] ||
                      values["dcterm:creator"] ||
                      values["author"];

    // get description
    metadata.excerpt = jsonld.excerpt ||
                       values["dc:description"] ||
                       values["dcterm:description"] ||
                       values["og:description"] ||
                       values["weibo:article:description"] ||
                       values["weibo:webpage:description"] ||
                       values["description"] ||
                       values["twitter:description"];

    // get site name
    metadata.siteName = jsonld.siteName ||
                        values["og:site_name"];

    // get article published time
    metadata.publishedTime = jsonld.datePublished ||
      values["article:published_time"] || null;

    // in many sites the meta value is escaped with HTML entities,
    // so here we need to unescape it
    metadata.title = this._unescapeHtmlEntities(metadata.title);
    metadata.byline = this._unescapeHtmlEntities(metadata.byline);
    metadata.excerpt = this._unescapeHtmlEntities(metadata.excerpt);
    metadata.siteName = this._unescapeHtmlEntities(metadata.siteName);
    metadata.publishedTime = this._unescapeHtmlEntities(metadata.publishedTime);

    return metadata;
  },

  /**
   * Check if node is image, or if node contains exactly only one image
   * whether as a direct child or as its descendants.
   *
   * @param Element
  **/
  _isSingleImage: function(node) {
    if (node.tagName === "IMG") {
      return true;
    }

    if (node.children.length !== 1 || node.textContent.trim() !== "") {
      return false;
    }

    return this._isSingleImage(node.children[0]);
  },

  /**
   * Find all <noscript> that are located after <img> nodes, and which contain only one
   * <img> element. Replace the first image with the image from inside the <noscript> tag,
   * and remove the <noscript> tag. This improves the quality of the images we use on
   * some sites (e.g. Medium).
   *
   * @param Element
  **/
  _unwrapNoscriptImages: function(doc) {
    // Find img without source or attributes that might contains image, and remove it.
    // This is done to prevent a placeholder img is replaced by img from noscript in next step.
    var imgs = Array.from(doc.getElementsByTagName("img"));
    this._forEachNode(imgs, function(img) {
      for (var i = 0; i < img.attributes.length; i++) {
        var attr = img.attributes[i];
        switch (attr.name) {
          case "src":
          case "srcset":
          case "data-src":
          case "data-srcset":
            return;
        }

        if (/\.(jpg|jpeg|png|webp)/i.test(attr.value)) {
          return;
        }
      }

      img.parentNode.removeChild(img);
    });

    // Next find noscript and try to extract its image
    var noscripts = Array.from(doc.getElementsByTagName("noscript"));
    this._forEachNode(noscripts, function(noscript) {
      // Parse content of noscript and make sure it only contains image
      var tmp = doc.createElement("div");
      tmp.innerHTML = noscript.innerHTML;
      if (!this._isSingleImage(tmp)) {
        return;
      }

      // If noscript has previous sibling and it only contains image,
      // replace it with noscript content. However we also keep old
      // attributes that might contains image.
      var prevElement = noscript.previousElementSibling;
      if (prevElement && this._isSingleImage(prevElement)) {
        var prevImg = prevElement;
        if (prevImg.tagName !== "IMG") {
          prevImg = prevElement.getElementsByTagName("img")[0];
        }

        var newImg = tmp.getElementsByTagName("img")[0];
        for (var i = 0; i < prevImg.attributes.length; i++) {
          var attr = prevImg.attributes[i];
          if (attr.value === "") {
            continue;
          }

          if (attr.name === "src" || attr.name === "srcset" || /\.(jpg|jpeg|png|webp)/i.test(attr.value)) {
            if (newImg.getAttribute(attr.name) === attr.value) {
              continue;
            }

            var attrName = attr.name;
            if (newImg.hasAttribute(attrName)) {
              attrName = "data-old-" + attrName;
            }

            newImg.setAttribute(attrName, attr.value);
          }
        }

        noscript.parentNode.replaceChild(tmp.firstElementChild, prevElement);
      }
    });
  },

  /**
   * Removes script tags from the document.
   *
   * @param Element
  **/
  _removeScripts: function(doc) {
    this._removeNodes(this._getAllNodesWithTag(doc, ["script", "noscript"]));
  },

  /**
   * Check if this node has only whitespace and a single element with given tag
   * Returns false if the DIV node contains non-empty text nodes
   * or if it contains no element with given tag or more than 1 element.
   *
   * @param Element
   * @param string tag of child element
  **/
  _hasSingleTagInsideElement: function(element, tag) {
    // There should be exactly 1 element child with given tag
    if (element.children.length != 1 || element.children[0].tagName !== tag) {
      return false;
    }

    // And there should be no text nodes with real content
    return !this._someNode(element.childNodes, function(node) {
      return node.nodeType === this.TEXT_NODE &&
             this.REGEXPS.hasContent.test(node.textContent);
    });
  },

  _isElementWithoutContent: function(node) {
    return node.nodeType === this.ELEMENT_NODE &&
      node.textContent.trim().length == 0 &&
      (node.children.length == 0 ||
       node.children.length == node.getElementsByTagName("br").length + node.getElementsByTagName("hr").length);
  },

  /**
   * Determine whether element has any children block level elements.
   *
   * @param Element
   */
  _hasChildBlockElement: function (element) {
    return this._someNode(element.childNodes, function(node) {
      return this.DIV_TO_P_ELEMS.has(node.tagName) ||
             this._hasChildBlockElement(node);
    });
  },

  /***
   * Determine if a node qualifies as phrasing content.
   * https://developer.mozilla.org/en-US/docs/Web/Guide/HTML/Content_categories#Phrasing_content
  **/
  _isPhrasingContent: function(node) {
    return node.nodeType === this.TEXT_NODE || this.PHRASING_ELEMS.indexOf(node.tagName) !== -1 ||
      ((node.tagName === "A" || node.tagName === "DEL" || node.tagName === "INS") &&
        this._everyNode(node.childNodes, this._isPhrasingContent));
  },

  _isWhitespace: function(node) {
    return (node.nodeType === this.TEXT_NODE && node.textContent.trim().length === 0) ||
           (node.nodeType === this.ELEMENT_NODE && node.tagName === "BR");
  },

  /**
   * Get the inner text of a node - cross browser compatibly.
   * This also strips out any excess whitespace to be found.
   *
   * @param Element
   * @param Boolean normalizeSpaces (default: true)
   * @return string
  **/
  _getInnerText: function(e, normalizeSpaces) {
    normalizeSpaces = (typeof normalizeSpaces === "undefined") ? true : normalizeSpaces;
    var textContent = e.textContent.trim();

    if (normalizeSpaces) {
      return textContent.replace(this.REGEXPS.normalize, " ");
    }
    return textContent;
  },

  /**
   * Get the number of times a string s appears in the node e.
   *
   * @param Element
   * @param string - what to split on. Default is ","
   * @return number (integer)
  **/
  _getCharCount: function(e, s) {
    s = s || ",";
    return this._getInnerText(e).split(s).length - 1;
  },

  /**
   * Remove the style attribute on every e and under.
   * TODO: Test if getElementsByTagName(*) is faster.
   *
   * @param Element
   * @return void
  **/
  _cleanStyles: function(e) {
    if (!e || e.tagName.toLowerCase() === "svg")
      return;

    // Remove `style` and deprecated presentational attributes
    for (var i = 0; i < this.PRESENTATIONAL_ATTRIBUTES.length; i++) {
      e.removeAttribute(this.PRESENTATIONAL_ATTRIBUTES[i]);
    }

    if (this.DEPRECATED_SIZE_ATTRIBUTE_ELEMS.indexOf(e.tagName) !== -1) {
      e.removeAttribute("width");
      e.removeAttribute("height");
    }

    var cur = e.firstElementChild;
    while (cur !== null) {
      this._cleanStyles(cur);
      cur = cur.nextElementSibling;
    }
  },

  /**
   * Get the density of links as a percentage of the content
   * This is the amount of text that is inside a link divided by the total text in the node.
   *
   * @param Element
   * @return number (float)
  **/
  _getLinkDensity: function(element) {
    var textLength = this._getInnerText(element).length;
    if (textLength === 0)
      return 0;

    var linkLength = 0;

    // XXX implement _reduceNodeList?
    this._forEachNode(element.getElementsByTagName("a"), function(linkNode) {
      var href = linkNode.getAttribute("href");
      var coefficient = href && this.REGEXPS.hashUrl.test(href) ? 0.3 : 1;
      linkLength += this._getInnerText(linkNode).length * coefficient;
    });

    return linkLength / textLength;
  },

  /**
   * Get an elements class/id weight. Uses regular expressions to tell if this
   * element looks good or bad.
   *
   * @param Element
   * @return number (Integer)
  **/
  _getClassWeight: function(e) {
    if (!this._flagIsActive(this.FLAG_WEIGHT_CLASSES))
      return 0;

    var weight = 0;

    // Look for a special classname
    if (typeof(e.className) === "string" && e.className !== "") {
      if (this.REGEXPS.negative.test(e.className))
        weight -= 25;

      if (this.REGEXPS.positive.test(e.className))
        weight += 25;
    }

    // Look for a special ID
    if (typeof(e.id) === "string" && e.id !== "") {
      if (this.REGEXPS.negative.test(e.id))
        weight -= 25;

      if (this.REGEXPS.positive.test(e.id))
        weight += 25;
    }

    return weight;
  },

  /**
   * Clean a node of all elements of type "tag".
   * (Unless it's a youtube/vimeo video. People love movies.)
   *
   * @param Element
   * @param string tag to clean
   * @return void
   **/
  _clean: function(e, tag) {
    var isEmbed = ["object", "embed", "iframe"].indexOf(tag) !== -1;

    this._removeNodes(this._getAllNodesWithTag(e, [tag]), function(element) {
      // Allow youtube and vimeo videos through as people usually want to see those.
      if (isEmbed) {
        // First, check the elements attributes to see if any of them contain youtube or vimeo
        for (var i = 0; i < element.attributes.length; i++) {
          if (this._allowedVideoRegex.test(element.attributes[i].value)) {
            return false;
          }
        }

        // For embed with <object> tag, check inner HTML as well.
        if (element.tagName === "object" && this._allowedVideoRegex.test(element.innerHTML)) {
          return false;
        }
      }

      return true;
    });
  },

  /**
   * Check if a given node has one of its ancestor tag name matching the
   * provided one.
   * @param  HTMLElement node
   * @param  String      tagName
   * @param  Number      maxDepth
   * @param  Function    filterFn a filter to invoke to determine whether this node 'counts'
   * @return Boolean
   */
  _hasAncestorTag: function(node, tagName, maxDepth, filterFn) {
    maxDepth = maxDepth || 3;
    tagName = tagName.toUpperCase();
    var depth = 0;
    while (node.parentNode) {
      if (maxDepth > 0 && depth > maxDepth)
        return false;
      if (node.parentNode.tagName === tagName && (!filterFn || filterFn(node.parentNode)))
        return true;
      node = node.parentNode;
      depth++;
    }
    return false;
  },

  /**
   * Return an object indicating how many rows and columns this table has.
   */
  _getRowAndColumnCount: function(table) {
    var rows = 0;
    var columns = 0;
    var trs = table.getElementsByTagName("tr");
    for (var i = 0; i < trs.length; i++) {
      var rowspan = trs[i].getAttribute("rowspan") || 0;
      if (rowspan) {
        rowspan = parseInt(rowspan, 10);
      }
      rows += (rowspan || 1);

      // Now look for column-related info
      var columnsInThisRow = 0;
      var cells = trs[i].getElementsByTagName("td");
      for (var j = 0; j < cells.length; j++) {
        var colspan = cells[j].getAttribute("colspan") || 0;
        if (colspan) {
          colspan = parseInt(colspan, 10);
        }
        columnsInThisRow += (colspan || 1);
      }
      columns = Math.max(columns, columnsInThisRow);
    }
    return {rows: rows, columns: columns};
  },

  /**
   * Look for 'data' (as opposed to 'layout') tables, for which we use
   * similar checks as
   * https://searchfox.org/mozilla-central/rev/f82d5c549f046cb64ce5602bfd894b7ae807c8f8/accessible/generic/TableAccessible.cpp#19
   */
  _markDataTables: function(root) {
    var tables = root.getElementsByTagName("table");
    for (var i = 0; i < tables.length; i++) {
      var table = tables[i];
      var role = table.getAttribute("role");
      if (role == "presentation") {
        table._readabilityDataTable = false;
        continue;
      }
      var datatable = table.getAttribute("datatable");
      if (datatable == "0") {
        table._readabilityDataTable = false;
        continue;
      }
      var summary = table.getAttribute("summary");
      if (summary) {
        table._readabilityDataTable = true;
        continue;
      }

      var caption = table.getElementsByTagName("caption")[0];
      if (caption && caption.childNodes.length > 0) {
        table._readabilityDataTable = true;
        continue;
      }

      // If the table has a descendant with any of these tags, consider a data table:
      var dataTableDescendants = ["col", "colgroup", "tfoot", "thead", "th"];
      var descendantExists = function(tag) {
        return !!table.getElementsByTagName(tag)[0];
      };
      if (dataTableDescendants.some(descendantExists)) {
        this.log("Data table because found data-y descendant");
        table._readabilityDataTable = true;
        continue;
      }

      // Nested tables indicate a layout table:
      if (table.getElementsByTagName("table")[0]) {
        table._readabilityDataTable = false;
        continue;
      }

      var sizeInfo = this._getRowAndColumnCount(table);
      if (sizeInfo.rows >= 10 || sizeInfo.columns > 4) {
        table._readabilityDataTable = true;
        continue;
      }
      // Now just go by size entirely:
      table._readabilityDataTable = sizeInfo.rows * sizeInfo.columns > 10;
    }
  },

  /* convert images and figures that have properties like data-src into images that can be loaded without JS */
  _fixLazyImages: function (root) {
    this._forEachNode(this._getAllNodesWithTag(root, ["img", "picture", "figure"]), function (elem) {
      // In some sites (e.g. Kotaku), they put 1px square image as base64 data uri in the src attribute.
      // So, here we check if the data uri is too short, just might as well remove it.
      if (elem.src && this.REGEXPS.b64DataUrl.test(elem.src)) {
        // Make sure it's not SVG, because SVG can have a meaningful image in under 133 bytes.
        var parts = this.REGEXPS.b64DataUrl.exec(elem.src);
        if (parts[1] === "image/svg+xml") {
          return;
        }

        // Make sure this element has other attributes which contains image.
        // If it doesn't, then this src is important and shouldn't be removed.
        var srcCouldBeRemoved = false;
        for (var i = 0; i < elem.attributes.length; i++) {
          var attr = elem.attributes[i];
          if (attr.name === "src") {
            continue;
          }

          if (/\.(jpg|jpeg|png|webp)/i.test(attr.value)) {
            srcCouldBeRemoved = true;
            break;
          }
        }

        // Here we assume if image is less than 100 bytes (or 133B after encoded to base64)
        // it will be too small, therefore it might be placeholder image.
        if (srcCouldBeRemoved) {
          var b64starts = elem.src.search(/base64\s*/i) + 7;
          var b64length = elem.src.length - b64starts;
          if (b64length < 133) {
            elem.removeAttribute("src");
          }
        }
      }

      // also check for "null" to work around https://github.com/jsdom/jsdom/issues/2580
      if ((elem.src || (elem.srcset && elem.srcset != "null")) && elem.className.toLowerCase().indexOf("lazy") === -1) {
        return;
      }

      for (var j = 0; j < elem.attributes.length; j++) {
        attr = elem.attributes[j];
        if (attr.name === "src" || attr.name === "srcset" || attr.name === "alt") {
          continue;
        }
        var copyTo = null;
        if (/\.(jpg|jpeg|png|webp)\s+\d/.test(attr.value)) {
          copyTo = "srcset";
        } else if (/^\s*\S+\.(jpg|jpeg|png|webp)\S*\s*$/.test(attr.value)) {
          copyTo = "src";
        }
        if (copyTo) {
          //if this is an img or picture, set the attribute directly
          if (elem.tagName === "IMG" || elem.tagName === "PICTURE") {
            elem.setAttribute(copyTo, attr.value);
          } else if (elem.tagName === "FIGURE" && !this._getAllNodesWithTag(elem, ["img", "picture"]).length) {
            //if the item is a <figure> that does not contain an image or picture, create one and place it inside the figure
            //see the nytimes-3 testcase for an example
            var img = this._doc.createElement("img");
            img.setAttribute(copyTo, attr.value);
            elem.appendChild(img);
          }
        }
      }
    });
  },

  _getTextDensity: function(e, tags) {
    var textLength = this._getInnerText(e, true).length;
    if (textLength === 0) {
      return 0;
    }
    var childrenLength = 0;
    var children = this._getAllNodesWithTag(e, tags);
    this._forEachNode(children, (child) => childrenLength += this._getInnerText(child, true).length);
    return childrenLength / textLength;
  },

  /**
   * Clean an element of all tags of type "tag" if they look fishy.
   * "Fishy" is an algorithm based on content length, classnames, link density, number of images & embeds, etc.
   *
   * @return void
   **/
  _cleanConditionally: function(e, tag) {
    if (!this._flagIsActive(this.FLAG_CLEAN_CONDITIONALLY))
      return;

    // Gather counts for other typical elements embedded within.
    // Traverse backwards so we can remove nodes at the same time
    // without effecting the traversal.
    //
    // TODO: Consider taking into account original contentScore here.
    this._removeNodes(this._getAllNodesWithTag(e, [tag]), function(node) {
      // First check if this node IS data table, in which case don't remove it.
      var isDataTable = function(t) {
        return t._readabilityDataTable;
      };

      var isList = tag === "ul" || tag === "ol";
      if (!isList) {
        var listLength = 0;
        var listNodes = this._getAllNodesWithTag(node, ["ul", "ol"]);
        this._forEachNode(listNodes, (list) => listLength += this._getInnerText(list).length);
        isList = listLength / this._getInnerText(node).length > 0.9;
      }

      if (tag === "table" && isDataTable(node)) {
        return false;
      }

      // Next check if we're inside a data table, in which case don't remove it as well.
      if (this._hasAncestorTag(node, "table", -1, isDataTable)) {
        return false;
      }

      if (this._hasAncestorTag(node, "code")) {
        return false;
      }

      var weight = this._getClassWeight(node);

      this.log("Cleaning Conditionally", node);

      var contentScore = 0;

      if (weight + contentScore < 0) {
        return true;
      }

      if (this._getCharCount(node, ",") < 10) {
        // If there are not very many commas, and the number of
        // non-paragraph elements is more than paragraphs or other
        // ominous signs, remove the element.
        var p = node.getElementsByTagName("p").length;
        var img = node.getElementsByTagName("img").length;
        var li = node.getElementsByTagName("li").length - 100;
        var input = node.getElementsByTagName("input").length;
        var headingDensity = this._getTextDensity(node, ["h1", "h2", "h3", "h4", "h5", "h6"]);

        var embedCount = 0;
        var embeds = this._getAllNodesWithTag(node, ["object", "embed", "iframe"]);

        for (var i = 0; i < embeds.length; i++) {
          // If this embed has attribute that matches video regex, don't delete it.
          for (var j = 0; j < embeds[i].attributes.length; j++) {
            if (this._allowedVideoRegex.test(embeds[i].attributes[j].value)) {
              return false;
            }
          }

          // For embed with <object> tag, check inner HTML as well.
          if (embeds[i].tagName === "object" && this._allowedVideoRegex.test(embeds[i].innerHTML)) {
            return false;
          }

          embedCount++;
        }

        var linkDensity = this._getLinkDensity(node);
        var contentLength = this._getInnerText(node).length;

        var haveToRemove =
          (img > 1 && p / img < 0.5 && !this._hasAncestorTag(node, "figure")) ||
          (!isList && li > p) ||
          (input > Math.floor(p/3)) ||
          (!isList && headingDensity < 0.9 && contentLength < 25 && (img === 0 || img > 2) && !this._hasAncestorTag(node, "figure")) ||
          (!isList && weight < 25 && linkDensity > 0.2) ||
          (weight >= 25 && linkDensity > 0.5) ||
          ((embedCount === 1 && contentLength < 75) || embedCount > 1);
        // Allow simple lists of images to remain in pages
        if (isList && haveToRemove) {
          for (var x = 0; x < node.children.length; x++) {
            let child = node.children[x];
            // Don't filter in lists with li's that contain more than one child
            if (child.children.length > 1) {
              return haveToRemove;
            }
          }
          let li_count = node.getElementsByTagName("li").length;
          // Only allow the list to remain if every li contains an image
          if (img == li_count) {
            return false;
          }
        }
        return haveToRemove;
      }
      return false;
    });
  },

  /**
   * Clean out elements that match the specified conditions
   *
   * @param Element
   * @param Function determines whether a node should be removed
   * @return void
   **/
  _cleanMatchedNodes: function(e, filter) {
    var endOfSearchMarkerNode = this._getNextNode(e, true);
    var next = this._getNextNode(e);
    while (next && next != endOfSearchMarkerNode) {
      if (filter.call(this, next, next.className + " " + next.id)) {
        next = this._removeAndGetNext(next);
      } else {
        next = this._getNextNode(next);
      }
    }
  },

  /**
   * Clean out spurious headers from an Element.
   *
   * @param Element
   * @return void
  **/
  _cleanHeaders: function(e) {
    let headingNodes = this._getAllNodesWithTag(e, ["h1", "h2"]);
    this._removeNodes(headingNodes, function(node) {
      let shouldRemove = this._getClassWeight(node) < 0;
      if (shouldRemove) {
        this.log("Removing header with low class weight:", node);
      }
      return shouldRemove;
    });
  },

  /**
   * Check if this node is an H1 or H2 element whose content is mostly
   * the same as the article title.
   *
   * @param Element  the node to check.
   * @return boolean indicating whether this is a title-like header.
   */
  _headerDuplicatesTitle: function(node) {
    if (node.tagName != "H1" && node.tagName != "H2") {
      return false;
    }
    var heading = this._getInnerText(node, false);
    this.log("Evaluating similarity of header:", heading, this._articleTitle);
    return this._textSimilarity(this._articleTitle, heading) > 0.75;
  },

  _flagIsActive: function(flag) {
    return (this._flags & flag) > 0;
  },

  _removeFlag: function(flag) {
    this._flags = this._flags & ~flag;
  },

  _isProbablyVisible: function(node) {
    // Have to null-check node.style and node.className.indexOf to deal with SVG and MathML nodes.
    return (!node.style || node.style.display != "none")
      && (!node.style || node.style.visibility != "hidden")
      && !node.hasAttribute("hidden")
      //check for "fallback-image" so that wikimedia math images are displayed
      && (!node.hasAttribute("aria-hidden") || node.getAttribute("aria-hidden") != "true" || (node.className && node.className.indexOf && node.className.indexOf("fallback-image") !== -1));
  },

  /**
   * Runs readability.
   *
   * Workflow:
   *  1. Prep the document by removing script tags, css, etc.
   *  2. Build readability's DOM tree.
   *  3. Grab the article content from the current dom tree.
   *  4. Replace the current DOM tree with the new one.
   *  5. Read peacefully.
   *
   * @return void
   **/
  parse: function () {
    // Avoid parsing too large documents, as per configuration option
    if (this._maxElemsToParse > 0) {
      var numTags = this._doc.getElementsByTagName("*").length;
      if (numTags > this._maxElemsToParse) {
        throw new Error("Aborting parsing document; " + numTags + " elements found");
      }
    }

    // Unwrap image from noscript
    this._unwrapNoscriptImages(this._doc);

    // Extract JSON-LD metadata before removing scripts
    var jsonLd = this._disableJSONLD ? {} : this._getJSONLD(this._doc);

    // Remove script tags from the document.
    this._removeScripts(this._doc);

    this._prepDocument();

    var metadata = this._getArticleMetadata(jsonLd);
    this._articleTitle = metadata.title;

    var articleContent = this._grabArticle();
    if (!articleContent)
      return null;

    this.log("Grabbed: " + articleContent.innerHTML);

    this._postProcessContent(articleContent);

    // If we haven't found an excerpt in the article's metadata, use the article's
    // first paragraph as the excerpt. This is used for displaying a preview of
    // the article's content.
    if (!metadata.excerpt) {
      var paragraphs = articleContent.getElementsByTagName("p");
      if (paragraphs.length > 0) {
        metadata.excerpt = paragraphs[0].textContent.trim();
      }
    }

    var textContent = articleContent.textContent;
    return {
      title: this._articleTitle,
      byline: metadata.byline || this._articleByline,
      dir: this._articleDir,
      lang: this._articleLang,
      content: this._serializer(articleContent),
      textContent: textContent,
      length: textContent.length,
      excerpt: metadata.excerpt,
      siteName: metadata.siteName || this._articleSiteName,
      publishedTime: metadata.publishedTime
    };
  }
};

if (typeof module === "object") {
  /* global module */
  module.exports = Readability;
}


================================================
FILE: bookmarks/styles/auth.css
================================================
.auth-page {
  margin: 0 auto;
  max-width: 350px;
}


================================================
FILE: bookmarks/styles/bookmark-details.css
================================================
.bookmark-details {
  .modal-container {
    width: 100%;
  }

  .title {
    word-break: break-word;
    display: -webkit-box;
    -webkit-box-orient: vertical;
    -webkit-line-clamp: 5;
    overflow: hidden;
  }

  & .weblinks {
    display: flex;
    flex-direction: column;
    gap: var(--unit-2);
  }

  & a.weblink {
    display: flex;
    align-items: center;
    gap: var(--unit-2);
  }

  & a.weblink img,
  & a.weblink svg {
    flex: 0 0 auto;
    width: 16px;
    height: 16px;
    color: var(--text-color);
  }

  & a.weblink span {
    flex: 1 1 0;
    white-space: nowrap;
    overflow: hidden;
    text-overflow: ellipsis;
  }

  & .preview-image {
    margin: var(--unit-4) 0;

    img {
      max-width: 100%;
      max-height: 200px;
    }
  }

  & .sections section {
    margin-top: var(--unit-4);
  }

  & .sections h3 {
    margin-bottom: var(--unit-2);
    font-size: var(--font-size);
    font-weight: bold;
  }

  & .assets {
    margin-top: var(--unit-2);

    & .filesize {
      color: var(--tertiary-text-color);
    }
  }

  & .assets-actions {
    display: flex;
    gap: var(--unit-4);
    align-items: center;
    margin-top: var(--unit-2);

    & .btn.btn-link {
      height: unset;
      padding: 0;
      border: none;
    }
  }

  & .tags a {
    color: var(--alternative-color);
  }

  & .status form {
    display: flex;
    gap: var(--unit-2);
  }

  & .status .form-group,
  .status .form-switch {
    margin: 0;
  }

  & .actions {
    display: flex;
    justify-content: space-between;
    align-items: center;
  }
}


================================================
FILE: bookmarks/styles/bookmark-form.css
================================================
.bookmarks-form-page {
  main {
    max-width: 550px;
    margin: 0 auto;
  }
}

.bookmarks-form {
  & .has-icon-right > input,
  & .has-icon-right > textarea {
    padding-right: 30px;
  }

  & .form-icon.loading {
    visibility: hidden;
  }

  & .form-group .suffix-button {
    padding: 0;
    border: none;
    height: auto;
    font-size: var(--font-size-sm);
  }

  & .form-group ld-clear-button,
  & .form-group #refresh-button {
    display: none;
  }

  & .form-group input.modified,
  & .form-group textarea.modified {
    background: var(--primary-color-shade);
  }

  & .form-input-hint.bookmark-exists {
    display: none;
    color: var(--warning-color);
  }

  & .form-input-hint.auto-tags {
    display: none;
    color: var(--success-color);
  }

  & details.notes textarea {
    box-sizing: border-box;
  }
}


================================================
FILE: bookmarks/styles/bookmark-page.css
================================================
:root {
  --bookmark-title-color: var(--primary-text-color);
  --bookmark-title-weight: 500;
  --bookmark-description-color: var(--text-color);
  --bookmark-description-weight: 400;
  --bookmark-actions-color: var(--secondary-text-color);
  --bookmark-actions-hover-color: var(--text-color);
  --bookmark-actions-weight: 400;
  --bulk-actions-bg-color: var(--gray-50);
}

/* Bookmark page grid */
.bookmarks-page {
  &.grid {
    grid-gap: var(--unit-9);
  }

  ld-filter-drawer-trigger {
    display: none;
  }

  @media (max-width: 840px) {
    section.side-panel {
      display: none;
    }

    ld-filter-drawer-trigger {
      display: inline-block;
    }
  }

  &.collapse-side-panel {
    main {
      grid-column: span var(--grid-columns);
    }

    .side-panel {
      display: none;
    }

    ld-filter-drawer-trigger {
      display: inline-block;
    }
  }
}

/* Bookmark area header controls */
.bookmarks-page .search-container {
  flex: 1 1 0;
  display: flex;
  max-width: 300px;
  margin-left: auto;

  & form {
    width: 100%;
  }

  @media (max-width: 600px) {
    max-width: initial;
    margin-left: 0;
  }

  /* Group search options button with search button */
  height: var(--control-size);
  border-radius: var(--border-radius);
  box-shadow: var(--box-shadow-xs);

  & input,
  & .form-autocomplete-input {
    border-top-right-radius: 0;
    border-bottom-right-radius: 0;
    box-shadow: none;
  }

  & .dropdown-toggle {
    border-left: none;
    border-top-left-radius: 0;
    border-bottom-left-radius: 0;
    box-shadow: none;
    outline-offset: calc(var(--focus-outline-offset) * -1);
  }

  /* Search option menu styles */

  & .dropdown {
    & .menu {
      padding: var(--unit-4);
      min-width: 250px;
      font-size: var(--font-size-sm);
    }

    & .menu .actions {
      margin-top: var(--unit-4);
      display: flex;
      justify-content: space-between;
    }

    & .form-group:first-of-type {
      margin-top: 0;
    }

    & .form-group {
      margin-bottom: var(--unit-3);
    }

    & .radio-group {
      & .form-label {
        margin-bottom: var(--unit-1);
      }

      & .form-radio.form-inline {
        margin: 0 var(--unit-2) 0 0;
        padding: 0;
        display: inline-flex;
        align-items: center;
        column-gap: var(--unit-1);
      }

      & .form-icon {
        top: 0;
        position: relative;
      }
    }
  }
}

/* Bookmark list */
@keyframes appear {
  0% {
    opacity: 0;
  }
  90% {
    opacity: 0;
  }
  100% {
    opacity: 1;
  }
}

ul.bookmark-list {
  list-style: none;
  margin: var(--unit-4) 0 0 0;
  padding: 0;

  /* Increase line-height for better separation within / between items */
  line-height: 1.1rem;

  > li {
    position: relative;
    display: flex;
    gap: var(--unit-2);
    margin-top: 0;
    margin-bottom: var(--unit-3);

    & .content {
      flex: 1 1 0;
      min-width: 0;
    }

    & .preview-image {
      flex: 0 0 auto;
      width: 100px;
      height: 60px;
      margin-top: var(--unit-h);
      border-radius: var(--border-radius);
      border: solid 1px var(--border-color);
      object-fit: cover;

      &.placeholder {
        display: flex;
        align-items: center;
        justify-content: center;
        background: var(--body-color-contrast);

        & .img {
          width: var(--unit-12);
          height: var(--unit-12);
          background-color: var(--tertiary-text-color);
          -webkit-mask: url(preview-placeholder.svg) no-repeat center;
          mask: url(preview-placeholder.svg) no-repeat center;
        }
      }
    }

    & .title {
      position: relative;
    }

    & .title img {
      position: absolute;
      width: 16px;
      height: 16px;
      left: 0;
      top: 50%;
      transform: translateY(-50%);
      pointer-events: none;
    }

    & .title img + a {
      padding-left: 22px;
    }

    & .title a {
      color: var(--bookmark-title-color);
      font-weight: var(--bookmark-title-weight);
      display: block;
      width: 100%;
      white-space: nowrap;
      overflow: hidden;
      text-overflow: ellipsis;
    }

    & .title a[data-tooltip]:hover::after,
    & .title a[data-tooltip]:focus::after {
      content: attr(data-tooltip);
      position: absolute;
      z-index: 10;
      top: 100%;
      left: 50%;
      transform: translateX(-50%);
      width: max-content;
      max-width: 90%;
      height: fit-content;
      background-color: #292f62;
      color: #fff;
      padding: var(--unit-1);
      border-radius: var(--border-radius);
      border: 1px solid #424a8c;
      font-size: var(--font-size-sm);
      font-style: normal;
      white-space: normal;
      pointer-events: none;
      animation: 0.3s ease 0s appear;
    }

    @media (pointer: coarse) {
      & .title a[data-tooltip]::after {
        display: none;
      }
    }

    &.unread .title a {
      font-style: italic;
    }

    & .url-path,
    & .url-display {
      font-size: var(--font-size-sm);
      color: var(--secondary-link-color);
    }

    & .description {
      color: var(--bookmark-description-color);
      font-weight: var(--bookmark-description-weight);
    }

    & .description.separate {
      display: -webkit-box;
      -webkit-box-orient: vertical;
      -webkit-line-clamp: var(--ld-bookmark-description-max-lines, 1);
      overflow: hidden;
    }

    & .tags {
      & a,
      & a:visited:hover {
        color: var(--alternative-color);
      }
      & a:not(:last-child) {
        margin-right: var(--unit-1);
      }
    }

    & .actions,
    & .extra-actions {
      display: flex;
      align-items: baseline;
      flex-wrap: wrap;
      column-gap: var(--unit-2);
    }

    @media (max-width: 600px) {
      & .extra-actions {
        width: 100%;
        margin-top: var(--unit-1);
      }
    }

    & .actions {
      color: var(--bookmark-actions-color);
      font-size: var(--font-size-sm);

      & a,
      & button.btn-link {
        color: var(--bookmark-actions-color);
        --btn-icon-color: var(--bookmark-actions-color);
        font-weight: var(--bookmark-actions-weight);
        padding: 0;
        height: auto;
        vertical-align: unset;
        border: none;
        box-sizing: border-box;
        transition: none;
        text-decoration: none;

        &:focus,
        &:hover,
        &:active,
        &.active {
          color: var(--bookmark-actions-hover-color);
          --btn-icon-color: var(--bookmark-actions-hover-color);
        }
      }
    }
  }
}

/* Bookmark pagination */
.bookmark-pagination {
  margin-top: var(--unit-4);

  &.sticky {
    position: sticky;
    bottom: 0;
    border-top: solid 1px var(--secondary-border-color);
    background: var(--body-color);
    padding-bottom: var(--unit-h);

    &:before {
      content: "";
      position: absolute;
      top: 0;
      bottom: 0;
      left: calc(
        -1 *
          calc(var(--bulk-edit-toggle-width) + var(--bulk-edit-toggle-offset))
      );
      width: calc(
        var(--bulk-edit-toggle-width) + var(--bulk-edit-toggle-offset)
      );
      background: var(--body-color);
    }
  }

  & .pagination {
    overflow: hidden;
  }
}

.bundle-menu {
  list-style-type: none;
  margin: 0 0 var(--unit-6);

  .bundle-menu-item {
    margin: 0;
    margin-bottom: var(--unit-2);
  }

  .bundle-menu-item a {
    padding: var(--unit-1) var(--unit-2);
    border-radius: var(--border-radius);
  }

  .bundle-menu-item.selected a {
    background: var(--primary-color);
    color: var(--contrast-text-color);
  }
}

.tag-cloud {
  /* Increase line-height for better separation within / between items */
  line-height: 1.1rem;

  & .selected-tags {
    margin-bottom: var(--unit-4);

    & a,
    & a:visited:hover {
      color: var(--error-color);
    }
  }

  & .unselected-tags {
    & a,
    & a:visited:hover {
      color: var(--alternative-color);
    }
  }

  & .group {
    margin-bottom: var(--unit-3);
  }

  & .highlight-char {
    font-weight: bold;
    text-transform: uppercase;
    color: var(--alternative-color-dark);
  }
}

/* Bookmark notes */
ul.bookmark-list {
  & .notes {
    display: none;
    max-height: 300px;
    margin: var(--unit-1) 0;
    overflow-y: auto;
    background: var(--body-color-contrast);
    border-radius: var(--border-radius);
  }

  & .notes .markdown {
    padding: var(--unit-2) var(--unit-3);
  }

  &.show-notes .notes,
  & li.show-notes .notes {
    display: block;
  }
}

/* Bookmark bulk edit */
:root {
  --bulk-edit-toggle-width: 16px;
  --bulk-edit-toggle-offset: 8px;
  --bulk-edit-bar-offset: calc(
    var(--bulk-edit-toggle-width) + (2 * var(--bulk-edit-toggle-offset))
  );
}

ld-bookmark-page {
  & .bulk-edit-bar {
    display: none;
    align-items: center;
    padding: var(--unit-1) 0;
    gap: var(--unit-2);
    background: var(--bulk-actions-bg-color);
    border-bottom: solid 1px var(--secondary-border-color);

    /* Actions */
    & button {
      --control-padding-x-sm: 0;
    }

    & button:hover {
      text-decoration: underline;
    }

    & > input,
    & .form-autocomplete,
    & select {
      width: auto;
      max-width: 140px;
      -webkit-appearance: none;
    }

    & .select-across {
      margin: 0 0 0 auto;
      font-size: var(--font-size-sm);
    }
  }

  &.active .bulk-edit-bar {
    display: flex;
  }

  /* All checkbox */

  & .form-checkbox.bulk-edit-checkbox.all {
    display: block;
    width: var(--bulk-edit-toggle-width);
    margin: 0 0 0 var(--bulk-edit-toggle-offset);
    padding: 0;
  }

  /* Bookmark checkboxes */

  & .form-checkbox.bulk-edit-checkbox:not(.all) {
    display: none;
    position: absolute;
    width: var(--bulk-edit-toggle-width);
    min-height: var(--bulk-edit-toggle-width);
    left: calc(
      -1 * var(--bulk-edit-toggle-width) - var(--bulk-edit-toggle-offset)
    );
    top: 50%;
    transform: translateY(-50%);
    padding: 0;
    margin: 0;

    .form-icon {
      top: 0;
    }
  }

  &.active .form-checkbox.bulk-edit-checkbox:not(.all) {
    display: block;
  }

  &.active ul.bookmark-list > li {
    padding-left: calc(
      var(--bulk-edit-toggle-width) + calc(var(--bulk-edit-toggle-offset) * 2)
    );
  }

  & ld-tag-autocomplete {
    display: none;
  }

  &[data-bulk-action="bulk_tag"],
  &[data-bulk-action="bulk_untag"] {
    & ld-tag-autocomplete {
      display: inline-block;
    }
  }
}


================================================
FILE: bookmarks/styles/bundles.css
================================================
.bundles-page {
  .crud-table {
    svg {
      cursor: grab;
    }

    tr.drag-start {
      --secondary-border-color: transparent;
    }

    tr.dragging > * {
      opacity: 0;
    }
  }
}

.bundles-editor-page {
  &.grid {
    gap: var(--unit-9);
  }

  .form-footer {
    position: sticky;
    bottom: 0;
    border-top: solid 1px var(--secondary-border-color);
    background: var(--body-color);
    padding: var(--unit-3) 0;
  }
}


================================================
FILE: bookmarks/styles/components.css
================================================
/* Shared components */

/* Section header component */
.section-header {
  border-bottom: solid 1px var(--secondary-border-color);
  display: flex;
  flex-wrap: wrap;
  column-gap: var(--unit-5);
  padding-bottom: var(--unit-2);
  margin-bottom: var(--unit-4);

  h1,
  h2,
  h3 {
    font-size: var(--font-size-lg);
    flex: 0 0 auto;
    line-height: var(--unit-9);
    margin: 0;
  }

  .header-controls {
    flex: 1 1 0;
    display: flex;
  }
}

@media (max-width: 600px) {
  .section-header:not(.no-wrap) {
    flex-direction: column;
  }
}

/* Confirm button component */
.confirm-dropdown.active {
  position: fixed;
  z-index: 500;

  & .menu {
    position: fixed;
    display: flex;
    flex-direction: column;
    box-sizing: border-box;
    gap: var(--unit-2);
    padding: var(--unit-2);
    transform: none;
  }
}

/* Divider */
.divider {
  border-bottom: solid 1px var(--secondary-border-color);
  margin: var(--unit-5) 0;
}

/* Turbo progress bar */
.turbo-progress-bar {
  background-color: var(--primary-color);
}

/* Messages */
.message-list {
  margin: var(--unit-4) 0;

  .toast {
    margin-bottom: var(--unit-2);
  }

  .toast a.btn-clear:visited {
    color: currentColor;
  }
}

/* Item list */
.item-list {
  & .list-item {
    display: flex;
    align-items: center;
    gap: var(--unit-2);
    padding: var(--unit-2) 0;
    border-top: var(--unit-o) solid var(--secondary-border-color);
  }

  & .list-item:last-child {
    border-bottom: var(--unit-o) solid var(--secondary-border-color);
  }

  & .list-item-icon {
    display: flex;
    align-items: center;
    justify-content: center;
  }

  & .list-item-text {
    flex: 1 1 0;
    gap: var(--unit-2);
    min-width: 0;
    display: flex;
  }

  & .list-item-text .truncate {
    flex-shrink: 1;
  }

  & .list-item-actions {
    display: flex;
    gap: var(--unit-2);
    margin-left: var(--unit-4);
    align-items: center;

    & .btn.btn-link {
      height: unset;
      padding: 0;
      border: none;
    }
  }
}


================================================
FILE: bookmarks/styles/crud.css
================================================
.crud-page {
  .crud-header {
    display: flex;
    justify-content: space-between;
    align-items: center;
    margin-bottom: var(--unit-6);

    h1 {
      font-size: var(--font-size-xl);
      margin: 0;
    }
  }

  .crud-filters {
    background: var(--body-color-contrast);
    border-radius: var(--border-radius);
    border: solid 1px var(--secondary-border-color);
    padding: var(--unit-3);
    margin-bottom: var(--unit-4);

    form {
      display: flex;
      flex-wrap: wrap;
      gap: var(--unit-4);

      & .form-group {
        margin: 0;
      }

      &.form-input,
      &.form-select {
        width: auto;
      }

      & .form-group:has(.form-checkbox) {
        align-self: flex-end;
      }
    }
  }
}

.crud-table {
  .btn.btn-link {
    padding: 0;
    height: unset;
  }

  th,
  td {
    max-width: 0;
    white-space: nowrap;
    overflow: hidden;
    text-overflow: ellipsis;
  }

  th.actions,
  td.actions {
    width: 1%;
    max-width: 150px;

    *:not(:last-child) {
      margin-right: var(--unit-2);
    }
  }
}


================================================
FILE: bookmarks/styles/layout.css
================================================
/* Main layout */
body {
  margin: 20px 10px;

  @media (min-width: 600px) {
    /* Horizontal offset accounts for checkboxes that show up in bulk edit mode */
    margin: 20px 32px;
  }
}

header {
  margin-bottom: var(--unit-9);

  a.app-link:hover {
    text-decoration: none;
  }

  .app-logo {
    width: 28px;
    height: 28px;
  }

  .app-name {
    margin-left: var(--unit-3);
    font-size: var(--font-size-lg);
    font-weight: 500;
    line-height: 1.2;
  }
}


================================================
FILE: bookmarks/styles/markdown.css
================================================
.markdown {
  & p,
  & ul,
  & ol,
  & pre,
  & blockquote {
    margin: 0 0 var(--unit-2) 0;
  }

  & > *:first-child {
    margin-top: 0;
  }

  & > *:last-child {
    margin-bottom: 0;
  }

  & ul,
  & ol {
    margin-left: var(--unit-4);
  }

  & ul li,
  & ol li {
    margin-top: var(--unit-1);
  }

  & pre {
    padding: var(--unit-1) var(--unit-2);
    background-color: var(--code-bg-color);
    border-radius: var(--unit-1);
    overflow-x: auto;
  }

  & pre code {
    background: none;
    box-shadow: none;
    padding: 0;
  }

  & > pre:first-child:last-child {
    padding: 0;
    background: none;
    border-radius: 0;
  }
}


================================================
FILE: bookmarks/styles/reader-mode.css
================================================
html.reader-mode {
  --font-size: 1rem;
  line-height: 1.6;

  body {
    margin: 3rem 2rem;
  }

  .container {
    max-width: 600px;
  }

  .byline {
    font-style: italic;
    font-size: 0.8rem;
  }

  .reading-time {
    font-size: 0.7rem;
  }

  img {
    max-width: 100%;
    height: auto;
  }
}


================================================
FILE: bookmarks/styles/responsive.css
================================================
.show-sm,
.show-md {
  display: none !important;
}

.width-25 {
  width: 25%;
}

.width-50 {
  width: 50%;
}

.width-75 {
  width: 75%;
}

.width-100 {
  width: 100%;
}

.container {
  margin-left: auto;
  margin-right: auto;
  width: 100%;
  max-width: var(--size-lg);
}

.grid {
  --grid-columns: 3;
  display: grid;
  grid-template-columns: repeat(var(--grid-columns), 1fr);
  grid-gap: var(--unit-4);
}

.grid > * {
  min-width: 0;
}

.columns-2 {
  --grid-columns: 2;
}

.gap-0 {
  gap: 0;
}

.col-1 {
  grid-column: span min(1, var(--grid-columns));
}

.col-2 {
  grid-column: span min(2, var(--grid-columns));
}

.col-3 {
  grid-column: span min(3, var(--grid-columns));
}

@media (max-width: 840px) {
  .hide-md {
    display: none !important;
  }
  .show-md {
    display: block !important;
  }

  .width-md-25 {
    width: 25%;
  }
  .width-md-50 {
    width: 50%;
  }
  .width-md-75 {
    width: 75%;
  }
  .width-md-100 {
    width: 100%;
  }

  .columns-md-1 {
    --grid-columns: 1;
  }
  .columns-md-2 {
    --grid-columns: 2;
  }
}

@media (max-width: 600px) {
  .hide-sm {
    display: none !important;
  }
  .show-sm {
    display: block !important;
  }

  .width-sm-25 {
    width: 25%;
  }
  .width-sm-50 {
    width: 50%;
  }
  .width-sm-75 {
    width: 75%;
  }
  .width-sm-100 {
    width: 100%;
  }

  .columns-sm-1 {
    --grid-columns: 1;
  }
  .columns-sm-2 {
    --grid-columns: 2;
  }
}


================================================
FILE: bookmarks/styles/settings.css
================================================
.settings-page {
  h1 {
    font-size: var(--font-size-xl);
    margin-bottom: var(--unit-6);
  }

  section {
    margin-bottom: var(--unit-10);

    h2 {
      font-size: var(--font-size-lg);
      margin-bottom: var(--unit-4);
    }
  }

  textarea.monospace {
    font-family: monospace;
    box-sizing: border-box;
  }

  .input-group > input[type="submit"] {
    height: auto;
  }

  section.about table {
    max-width: 400px;
  }

  & .form-group {
    margin-bottom: var(--unit-4);
  }
}


================================================
FILE: bookmarks/styles/tags.css
================================================
.tags-editor-page {
  main {
    max-width: 550px;
    margin: 0 auto;
  }
}

.tag-edit-modal {
  .modal-container {
    max-width: 400px;
  }
}


================================================
FILE: bookmarks/styles/theme/LICENSE
================================================
The MIT License (MIT)

Copyright (c) 2016 - 2020 Yan Zhu

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.


================================================
FILE: bookmarks/styles/theme/_normalize.css
================================================
/* Manually forked from Normalize.css */
/* normalize.css v5.0.0 | MIT License | github.com/necolas/normalize.css */

/**
 * 1. Change the default font family in all browsers (opinionated).
 * 2. Correct the line height in all browsers.
 * 3. Prevent adjustments of font size after orientation changes in
 *    IE on Windows Phone and in iOS.
 */

/* Document
   ========================================================================== */

html {
  font-family: sans-serif; /* 1 */
  -ms-text-size-adjust: 100%; /* 3 */
  -webkit-text-size-adjust: 100%; /* 3 */
}

/* Sections
   ========================================================================== */

/**
 * Remove the margin in all browsers (opinionated).
 */

body {
  margin: 0;
}

/**
 * Add the correct display in IE 9-.
 */

article,
aside,
footer,
header,
nav,
section {
  display: block;
}

/**
 * Correct the font size and margin on `h1` elements within `section` and
 * `article` contexts in Chrome, Firefox, and Safari.
 */

h1 {
  font-size: 2em;
  margin: 0.67em 0;
}

/* Grouping content
   ========================================================================== */

/**
 * Add the correct display in IE 9-.
 * 1. Add the correct display in IE.
 */

figcaption,
figure,
main {
  /* 1 */
  display: block;
}

/**
 * Add the correct margin in IE 8 (removed).
 */

/**
 * 1. Add the correct box sizing in Firefox.
 * 2. Show the overflow in Edge and IE.
 */

hr {
  box-sizing: content-box; /* 1 */
  height: 0; /* 1 */
  overflow: visible; /* 2 */
}

/**
 * 1. Correct the inheritance and scaling of font size in all browsers. (removed)
 * 2. Correct the odd `em` font sizing in all browsers.
 */

/* Text-level semantics
   ========================================================================== */

/**
 * 1. Remove the gray background on active links in IE 10.
 * 2. Remove gaps in links underline in iOS 8+ and Safari 8+.
 */

a {
  background-color: transparent; /* 1 */
  -webkit-text-decoration-skip: objects; /* 2 */
}

/**
 * Remove the outline on focused links when they are also active or hovered
 * in all browsers (opinionated).
 */

a:active,
a:hover {
  outline-width: 0;
}

/**
 * Modify default styling of address.
 */

address {
  font-style: normal;
}

/**
 * 1. Remove the bottom border in Firefox 39-.
 * 2. Add the correct text decoration in Chrome, Edge, IE, Opera, and Safari. (removed)
 */

/**
 * Prevent the duplicate application of `bolder` by the next rule in Safari 6.
 */

b,
strong {
  font-weight: inherit;
}

/**
 * Add the correct font weight in Chrome, Edge, and Safari.
 */

b,
strong {
  font-weight: bolder;
}

/**
 * 1. Correct the inheritance and scaling of font size in all browsers.
 * 2. Correct the odd `em` font sizing in all browsers.
 */

code,
kbd,
pre,
samp {
  font-family: var(--mono-font-family); /* 1 (changed) */
  font-size: 1em; /* 2 */
}

/**
 * Add the correct font style in Android 4.3-.
 */

dfn {
  font-style: italic;
}

/**
 * Add the correct background and color in IE 9-. (Removed)
 */

/**
 * Add the correct font size in all browsers.
 */

small {
  font-size: 80%;
  font-weight: 400; /* (added) */
}

/**
 * Prevent `sub` and `sup` elements from affecting the line height in
 * all browsers.
 */

sub,
sup {
  font-size: 75%;
  line-height: 0;
  position: relative;
  vertical-align: baseline;
}

sub {
  bottom: -0.25em;
}

sup {
  top: -0.5em;
}

/* Embedded content
   ========================================================================== */

/**
 * Add the correct display in IE 9-.
 */

audio,
video {
  display: inline-block;
}

/**
 * Add the correct display in iOS 4-7.
 */

audio:not([controls]) {
  display: none;
  height: 0;
}

/**
 * Remove the border on images inside links in IE 10-.
 */

img {
  border-style: none;
}

/**
 * Hide the overflow in IE.
 */

svg:not(:root) {
  overflow: hidden;
}

/* Forms
   ========================================================================== */

/**
 * 1. Change the font styles in all browsers (opinionated).
 * 2. Remove the margin in Firefox and Safari.
 */

button,
input,
optgroup,
select,
textarea {
  font-family: inherit; /* 1 (changed) */
  font-size: inherit; /* 1 (changed) */
  line-height: inherit; /* 1 (changed) */
  margin: 0; /* 2 */
}

/**
 * Show the overflow in IE.
 * 1. Show the overflow in Edge.
 */

button,
input {
  /* 1 */
  overflow: visible;
}

/**
 * Remove the inheritance of text transform in Edge, Firefox, and IE.
 * 1. Remove the inheritance of text transform in Firefox.
 */

button,
select {
  /* 1 */
  text-transform: none;
}

/**
 * 1. Prevent a WebKit bug where (2) destroys native `audio` and `video`
 *    controls in Android 4.
 * 2. Correct the inability to style clickable types in iOS and Safari.
 */

button,
html [type="button"], /* 1 */
[type="reset"],
[type="submit"] {
  -webkit-appearance: button; /* 2 */
}

/**
 * Remove the inner border and padding in Firefox.
 */

button::-moz-focus-inner,
[type="button"]::-moz-focus-inner,
[type="reset"]::-moz-focus-inner,
[type="submit"]::-moz-focus-inner {
  border-style: none;
  padding: 0;
}

/**
 * Restore the focus styles unset by the previous rule (removed).
 */

/**
 * Change the border, margin, and padding in all browsers (opinionated) (changed).
 */

fieldset {
  border: 0;
  margin: 0;
  padding: 0;
}

/**
 * 1. Correct the text wrapping in Edge and IE.
 * 2. Correct the color inheritance from `fieldset` elements in IE.
 * 3. Remove the padding so developers are not caught out when they zero out
 *    `fieldset` elements in all browsers.
 */

legend {
  box-sizing: border-box; /* 1 */
  color: inherit; /* 2 */
  display: table; /* 1 */
  max-width: 100%; /* 1 */
  padding: 0; /* 3 */
  white-space: normal; /* 1 */
}

/**
 * 1. Add the correct display in IE 9-.
 * 2. Add the correct vertical alignment in Chrome, Firefox, and Opera.
 */

progress {
  display: inline-block; /* 1 */
  vertical-align: baseline; /* 2 */
}

/**
 * Remove the default vertical scrollbar in IE.
 */

textarea {
  overflow: auto;
}

/**
 * 1. Add the correct box sizing in IE 10-.
 * 2. Remove the padding in IE 10-.
 */

[type="checkbox"],
[type="radio"] {
  box-sizing: border-box; /* 1 */
  padding: 0; /* 2 */
}

/**
 * Correct the cursor style of increment and decrement buttons in Chrome.
 */

[type="number"]::-webkit-inner-spin-button,
[type="number"]::-webkit-outer-spin-button {
  height: auto;
}

/**
 * 1. Correct the odd appearance in Chrome and Safari.
 * 2. Correct the outline style in Safari.
 */

[type="search"] {
  -webkit-appearance: textfield; /* 1 */
  outline-offset: -2px; /* 2 */
}

/**
 * Remove the inner padding and cancel buttons in Chrome and Safari on macOS.
 */

[type="search"]::-webkit-search-cancel-button,
[type="search"]::-webkit-search-decoration {
  -webkit-appearance: none;
}

/**
 * 1. Correct the inability to style clickable types in iOS and Safari.
 * 2. Change font properties to `inherit` in Safari.
 */

::-webkit-file-upload-button {
  -webkit-appearance: button; /* 1 */
  font: inherit; /* 2 */
}

/* Interactive
   ========================================================================== */

/*
 * Add the correct display in IE 9-.
 * 1. Add the correct display in Edge, IE, and Firefox.
 */

details, /* 1 */
menu {
  display: block;
}

/*
 * Add the correct display in all browsers.
 */

summary {
  display: list-item;
  outline: none;
}

/* Scripting
   ========================================================================== */

/**
 * Add the correct display in IE 9-.
 */

canvas {
  display: inline-block;
}

/**
 * Add the correct display in IE.
 */

template {
  display: none;
}

/* Hidden
   ========================================================================== */

/**
 * Add the correct display in IE 10-.
 */

[hidden] {
  display: none;
}


================================================
FILE: bookmarks/styles/theme/animations.css
================================================
/* Animations */
@keyframes loading {
  0% {
    transform: rotate(0deg);
  }
  100% {
    transform: rotate(360deg);
  }
}

@keyframes slide-down {
  0% {
    opacity: 0;
    transform: translateY(calc(-1 * var(--unit-8)));
  }
  100% {
    opacity: 1;
    transform: translateY(0);
  }
}

@keyframes fade-in {
  0% {
    opacity: 0;
  }
  100% {
    opacity: 1;
  }
}

@keyframes fade-out {
  0% {
    opacity: 1;
  }
  100% {
    opacity: 0;
  }
}


================================================
FILE: bookmarks/styles/theme/asian.css
================================================
/* Optimized for East Asian CJK */
html:lang(zh),
html:lang(zh-Hans),
.lang-zh,
.lang-zh-hans {
  font-family: var(--cjk-zh-hans-font-family);
}

html:lang(zh-Hant),
.lang-zh-hant {
  font-family: var(--cjk-zh-hant-font-family);
}

html:lang(ja),
.lang-ja {
  font-family: var(--cjk-jp-font-family);
}

html:lang(ko),
.lang-ko {
  font-family: var(--cjk-ko-font-family);
}

:lang(zh),
:lang(ja),
.lang-cjk {
  & ins,
  & u {
    border-bottom: var(--border-width) solid;
    text-decoration: none;
  }

  & del + del,
  & del + s,
  & ins + ins,
  & ins + u,
  & s + del,
  & s + s,
  & u + ins,
  & u + u {
    margin-left: 0.125em;
  }
}


================================================
FILE: bookmarks/styles/theme/autocomplete.css
================================================
/* Autocomplete */
.form-autocomplete {
  & .form-autocomplete-input {
    box-sizing: border-box;
    align-content: flex-start;
    display: flex;
    flex-wrap: wrap;
    background: var(--input-bg-color);
    height: var(--control-size);
    min-height: var(--control-size);
    padding: 0;

    &.is-focused {
      outline: var(--focus-outline);
      outline-offset: calc(var(--focus-outline-offset) * -1);
    }

    & .form-input {
      background: transparent;
      border-color: transparent;
      box-shadow: none;
      display: inline-block;
      flex: 1 0 auto;
      line-height: var(--unit-4);
      width: 100%;
      height: 100% !important;
      margin: 0;
      border: none;

      &:focus {
        outline: none;
      }
    }

    &:has(.is-error) {
      background: var(--error-color-shade);
      border-color: var(--error-color);

      &.is-focused {
        outline-color: var(--error-color);
      }
    }
  }

  &.small {
    .form-autocomplete-input {
      height: var(--control-size-sm);
      min-height: var(--control-size-sm);
    }

    .form-autocomplete-input input {
      padding: 0.05rem 0.3rem;
      font-size: var(--font-size-sm);
    }

    .menu .menu-item {
      font-size: var(--font-size-sm);
    }
  }

  & .menu {
    display: none;
    position: fixed;
    max-height: var(--menu-max-height, 200px);
    overflow: auto;

    & .menu-item {
      white-space: normal;
    }

    & .menu-item.selected > a,
    & .menu-item > a:hover {
      background: var(--menu-item-hover-bg-color);
      color: var(--menu-item-hover-color);
    }

    & .group-item,
    & .group-item:hover {
      margin-top: var(--unit-2);
      text-transform: uppercase;
      background: none;
      font-size: 0.6rem;
      font-weight: bold;
    }
  }

  & .menu.open {
    display: block;
  }
}


================================================
FILE: bookmarks/styles/theme/badges.css
================================================
/* Badges */
.badge {
  position: relative;
  white-space: nowrap;

  &[data-badge],
  &:not([data-badge]) {
    &::after {
      background: var(--primary-color);
      background-clip: padding-box;
      border-radius: 0.5rem;
      box-shadow: 0 0 0 1px var(--body-color);
      color: var(--contrast-text-color);
      content: attr(data-badge);
      display: inline-block;
      transform: translate(-0.05rem, -0.5rem);
    }
  }

  &[data-badge] {
    &::after {
      font-size: var(--font-size-sm);
      height: 0.9rem;
      line-height: 1;
      min-width: 0.9rem;
      padding: 0.1rem 0.2rem;
      text-align: center;
      white-space: nowrap;
    }
  }

  &:not([data-badge]),
  &[data-badge=""] {
    &::after {
      height: 6px;
      min-width: 6px;
      padding: 0;
      width: 6px;
    }
  }

  /* Badges for Buttons */

  &.btn {
    &::after {
      position: absolute;
      top: 0;
      right: 0;
      transform: translate(50%, -50%);
    }
  }

  /* Badges for Avatars */

  &.avatar {
    &::after {
      position: absolute;
      top: 14.64%;
      right: 14.64%;
      transform: translate(50%, -50%);
      z-index: var(--zindex-1);
    }
  }
}


================================================
FILE: bookmarks/styles/theme/base.css
================================================
/* Base */
*,
*::before,
*::after {
  box-sizing: inherit;
}

html {
  box-sizing: border-box;
  font-size: var(--html-font-size);
  line-height: var(--html-line-height);
  -webkit-tap-highlight-color: transparent;
}

/* Reserve space for vert. scrollbar to avoid layout shifting when scrollbars are added */
html {
  scrollbar-gutter: stable;
}

@media (pointer: coarse) {
  html {
    scrollbar-gutter: initial;
  }
}

body {
  background: var(--body-color);
  color: var(--text-color);
  font-family: var(--body-font-family);
  font-size: var(--font-size);
  overflow-x: hidden;
  text-rendering: optimizeLegibility;
}

a {
  color: var(--link-color);
  outline: none;
  text-decoration: none;
}

a:focus-visible {
  outline: var(--focus-outline);
  outline-offset: var(--focus-outline-offset);
}

a:focus,
a:hover,
a:active,
a.active {
  text-decoration: underline;
}

summary {
  cursor: pointer;
}

summary:focus-visible {
  outline: var(--focus-outline);
  outline-offset: var(--focus-outline-offset);
}


================================================
FILE: bookmarks/styles/theme/buttons.css
================================================
/* Buttons */
:root {
  --btn-bg-color: var(--body-color);
  --btn-hover-bg-color: var(--gray-50);
  --btn-border-color: var(--border-color);
  --btn-text-color: var(--text-color);
  --btn-icon-color: var(--icon-color);
  --btn-font-weight: 400;
  --btn-box-shadow: var(--box-shadow-xs);

  --btn-primary-bg-color: var(--primary-color);
  --btn-primary-hover-bg-color: var(--primary-color-highlight);
  --btn-primary-text-color: var(--contrast-text-color);

  --btn-success-bg-color: var(--success-color);
  --btn-success-hover-bg-color: var(--success-color-highlight);
  --btn-success-text-color: var(--contrast-text-color);

  --btn-error-bg-color: var(--error-color);
  --btn-error-hover-bg-color: var(--error-color-highlight);
  --btn-error-text-color: var(--contrast-text-color);

  --btn-link-text-color: var(--link-color);
  --btn-link-hover-text-color: var(--link-color);
}

.btn {
  appearance: none;
  background: var(--btn-bg-color);
  border: var(--border-width) solid var(--btn-border-color);
  border-radius: var(--border-radius);
  color: var(--btn-text-color);
  font-weight: var(--btn-font-weight);
  cursor: pointer;
  display: inline-flex;
  align-items: baseline;
  justify-content: center;
  font-size: var(--font-size);
  height: var(--control-size);
  line-height: var(--line-height);
  outline: none;
  padding: var(--control-padding-y) var(--control-padding-x);
  box-shadow: var(--btn-box-shadow);
  text-align: center;
  text-decoration: none;
  transition:
    background 0.2s,
    border 0.2s,
    box-shadow 0.2s,
    color 0.2s;
  user-select: none;
  vertical-align: middle;
  white-space: nowrap;

  &:focus-visible {
    outline: var(--focus-outline);
    outline-offset: var(--focus-outline-offset);
  }

  &:hover {
    background: var(--btn-hover-bg-color);
    text-decoration: none;
  }

  &[disabled],
  &:disabled,
  &.disabled {
    cursor: default;
    opacity: 0.5;
    pointer-events: none;
  }

  &:focus,
  &:hover,
  &:active,
  &.active {
    text-decoration: none;
  }

  /* Button Primary */

  &.btn-primary {
    background: var(--btn-primary-bg-color);
    border-color: transparent;
    color: var(--btn-primary-text-color);
    --btn-icon-color: var(--btn-primary-text-color);

    &:hover {
      background: var(--btn-primary-hover-bg-color);
    }

    &.loading {
      &::after {
        border-bottom-color: var(--btn-primary-text-color);
        border-left-color: var(--btn-primary-text-color);
      }
    }
  }

  /* Button Colors */

  &.btn-success {
    background: var(--btn-success-bg-color);
    border-color: transparent;
    color: var(--btn-success-text-color);
    --btn-icon-color: var(--btn-success-text-color);

    &:hover {
      background: var(--btn-success-hover-bg-color);
    }
  }

  &.btn-error {
    --btn-border-color: var(--error-color);
    --btn-text-color: var(--error-color);
    --btn-icon-color: var(--error-color);

    &:hover {
      --btn-hover-bg-color: var(--error-color-shade);
    }
  }

  /* Button no border */
  &.btn-noborder {
    border-color: transparent;
    box-shadow: none;
  }

  /* Button Link */

  &.btn-link {
    background: transparent;
    border-color: transparent;
    box-shadow: none;
    color: var(--btn-link-text-color);
    --btn-icon-color: var(--btn-link-text-color);

    &:hover {
      color: var(--btn-link-hover-text-color);
      --btn-icon-color: var(--btn-link-hover-text-color);
    }

    &:focus,
    &:hover,
    &:active,
    &.active {
      text-decoration: none;
    }
  }

  /* Button Sizes */

  &.btn-sm {
    font-size: var(--font-size-sm);
    height: var(--control-size-sm);
    padding: var(--control-padding-y-sm) var(--control-padding-x-sm);
  }

  &.btn-lg {
    font-size: var(--font-size-lg);
    height: var(--control-size-lg);
    padding: var(--control-padding-y-lg) var(--control-padding-x-lg);
  }

  /* Button Block */

  &.btn-block {
    display: block;
    width: 100%;
  }

  /* Button Action */

  &.btn-action {
    width: var(--control-size);
    padding-left: 0;
    padding-right: 0;

    &.btn-sm {
      width: var(--control-size-sm);
    }

    &.btn-lg {
      width: var(--control-size-lg);
    }
  }

  /* Button Clear */

  &.btn-clear {
    background: transparent;
    border: 0;
    color: currentColor;
    box-shadow: none;
    height: var(--unit-5);
    line-height: var(--unit-4);
    margin-left: var(--unit-1);
    margin-right: -2px;
    opacity: 1;
    padding: var(--unit-h);
    text-decoration: none;
    width: var(--unit-5);

    &::before {
      content: "\2715";
    }
  }

  /* Wider button */

  &.btn-wide {
    padding-left: var(--unit-6);
    padding-right: var(--unit-6);
  }

  /* Small icon button */

  &.btn-sm.btn-icon {
    display: inline-flex;
    align-items: baseline;
    gap: var(--unit-h);

    svg {
      align-self: center;
    }
  }

  /* Button icons */

  & svg {
    color: var(--btn-icon-color);
    align-self: center;
  }
}

/* Button groups */
.btn-group {
  display: inline-flex;
  flex-wrap: wrap;

  .btn {
    flex: 1 0 auto;

    &:first-child:not(:last-child) {
      border-bottom-right-radius: 0;
      border-top-right-radius: 0;
    }

    &:not(:first-child):not(:last-child) {
      border-radius: 0;
      margin-left: calc(-1 * var(--border-width));
    }

    &:last-child:not(:first-child) {
      border-bottom-left-radius: 0;
      border-top-left-radius: 0;
      margin-left: calc(-1 * var(--border-width));
    }

    &:focus,
    &:hover,
    &:active,
    &.active {
      z-index: var(--zindex-0);
    }
  }

  &.btn-group-block {
    display: flex;

    .btn {
      flex: 1 0 0;
    }
  }
}


================================================
FILE: bookmarks/styles/theme/code.css
================================================
/* Code */
:root {
  --code-bg-color: var(--body-color-contrast);
  --code-color: var(--text-color);
}

code {
  border-radius: var(--border-radius);
  line-height: 1.25;
  padding: 0.1rem 0.2rem;
  background: var(--code-bg-color);
  color: var(--code-color);
  font-size: 85%;
}

.code {
  border-radius: var(--border-radius);
  background: var(--code-bg-color);
  color: var(--text-color);
  position: relative;

  & code {
    color: inherit;
    display: block;
    line-height: 1.5;
    overflow-x: auto;
    padding: var(--unit-2);
    width: 100%;
  }
}


================================================
FILE: bookmarks/styles/theme/dropdowns.css
================================================
/* Dropdown */
.dropdown {
  --dropdown-focus-display: block;

  display: inline-block;
  position: relative;

  .menu {
    animation: fade-in 0.15s ease 1;
    display: none;
    left: 0;
    max-height: 50vh;
    overflow-y: auto;
    position: absolute;
    top: 100%;
  }

  &.dropdown-right {
    .menu {
      left: auto;
      right: 0;
    }
  }

  &:focus-within .menu {
    /* Use custom CSS property to allow disabling opening on focus when using JS */
    display: var(--dropdown-focus-display);
  }

  &.active .menu {
    /* Always show menu when class is added through JS */
    display: block;
  }

  /* Fix dropdown-toggle border radius in button groups */
  .btn-group {
    .dropdown-toggle:nth-last-child(2) {
      border-bottom-right-radius: var(--border-radius);
      border-top-right-radius: var(--border-radius);
    }
  }
}


================================================
FILE: bookmarks/styles/theme/empty.css
================================================
/* Empty states (or Blank slates) */
.empty {
  background: var(--body-color-contrast);
  border-radius: var(--border-radius);
  color: var(--secondary-text-color);
  text-align: center;
  padding: var(--unit-8) var(--unit-8);

  .empty-icon {
    margin-bottom: var(--layout-spacing-lg);
  }

  .empty-title,
  .empty-subtitle {
    margin: var(--layout-spacing) auto;
  }

  .empty-action {
    margin-top: var(--layout-spacing-lg);
  }
}


================================================
FILE: bookmarks/styles/theme/forms.css
================================================
/* Forms */
:root {
  --input-bg-color: var(--body-color);
  --input-disabled-bg-color: var(--gray-100);
  --input-text-color: var(--text-color);
  --input-hint-color: var(--secondary-text-color);
  --input-border-color: var(--border-color);
  --input-placeholder-color: var(--tertiary-text-color);
  --input-box-shadow: var(--box-shadow-xs);

  --checkbox-bg-color: var(--body-color);
  --checkbox-checked-bg-color: var(--primary-color);
  --checkbox-disabled-bg-color: var(--gray-100);
  --checkbox-border-color: var(--border-color);
  --checkbox-icon-color: #fff;

  --switch-bg-color: var(--gray-300);
  --switch-border-color: var(--gray-400);
  --switch-toggle-color: #fff;
}

.form-group {
  &:not(:last-child) {
    margin-bottom: var(--unit-4);
  }
}

fieldset {
  margin-bottom: var(--layout-spacing-lg);
}

legend {
  font-size: var(--font-size-lg);
  font-weight: 500;
  margin-bottom: var(--layout-spacing-lg);
}

/* Form element: Label */
.form-label {
  display: block;
  line-height: var(--line-height);
  margin-bottom: var(--unit-2);
  font-weight: 500;
}

details summary .form-label {
  margin-bottom: 0;
}

details[open] summary .form-label {
  margin-bottom: var(--unit-2);
}

/* Form element: Input */
.form-input {
  appearance: none;
  background: var(--input-bg-color);
  background-image: none;
  border: var(--border-width) solid var(--input-border-color);
  border-radius: var(--border-radius);
  box-shadow: var(--input-box-shadow);
  color: var(--input-text-color);
  display: block;
  font-size: var(--font-size);
  height: var(--control-size);
  line-height: var(--line-height);
  max-width: 100%;
  outline: none;
  padding: var(--control-padding-y) var(--control-padding-x);
  position: relative;
  transition:
    background 0.2s,
    border 0.2s,
    color 0.2s;
  width: 100%;

  &:focus {
    outline: var(--focus-outline);
    outline-offset: calc(var(--focus-outline-offset) * -1);
  }

  &::placeholder {
    color: var(--input-placeholder-color);
    opacity: 1;
  }

  /* Input sizes */

  &.input-sm {
    font-size: var(--font-size-sm);
    height: var(--control-size-sm);
    padding: var(--control-padding-y-sm) var(--control-padding-x-sm);
  }

  &.input-lg {
    font-size: var(--font-size-lg);
    height: var(--control-size-lg);
    padding: var(--control-padding-y-lg) var(--control-padding-x-lg);
  }

  &.input-inline {
    display: inline-block;
    vertical-align: middle;
    width: auto;
  }

  /* Input types */

  &[type="file"] {
    height: auto;
  }
}

/* Form element: Textarea */
textarea.form-input {
  &,
  &.input-lg,
  &.input-sm {
    height: auto;
  }
}

/* Form element: Input hint */
.form-input-hint {
  color: var(--input-hint-color);
  font-size: var(--font-size-sm);
  margin-top: var(--unit-1);

  .has-success &,
  .is-success + & {
    color: var(--success-color);
  }

  .has-error &,
  .is-error + & {
    color: var(--error-color);
  }

  &.is-error {
    color: var(--error-color);
  }
}

/* Form element: Select */
.form-select {
  appearance: none;
  background: var(--input-bg-color);
  border: var(--border-width) solid var(--input-border-color);
  border-radius: var(--border-radius);
  box-shadow: var(--input-box-shadow);
  color: var(--input-text-color);
  font-size: var(--font-size);
  height: var(--control-size);
  line-height: var(--line-height);
  outline: none;
  padding: var(--control-padding-y) var(--control-padding-x);
  vertical-align: middle;
  width: 100%;

  &:focus {
    outline: var(--focus-outline);
    outline-offset: calc(var(--focus-outline-offset) * -1);
  }

  /* Select sizes */

  &.select-sm {
    font-size: var(--font-size-sm);
    height: var(--control-size-sm);
    padding: var(--control-padding-y-sm)
      calc(var(--control-icon-size) + var(--control-padding-x-sm))
      var(--control-padding-y-sm) var(--control-padding-x-sm);
  }

  &.select-lg {
    font-size: var(--font-size-lg);
    height: var(--control-size-lg);
    padding: var(--control-padding-y-lg)
      calc(var(--control-icon-size) + var(--control-padding-x-lg))
      var(--control-padding-y-lg) var(--control-padding-x-lg);
  }

  /* Multiple select */

  &[size],
  &[multiple] {
    height: auto;
    padding: var(--control-padding-y) var(--control-padding-x);

    & option {
      padding: var(--unit-h) var(--unit-1);
    }
  }

  &:not([multiple]):not([size]) {
    background: var(--input-bg-color)
      url("data:image/svg+xml;charset=utf8,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%204%205'%3E%3Cpath%20fill='%23667189'%20d='M2%200L0%202h4zm0%205L0%203h4z'/%3E%3C/svg%3E")
      no-repeat right 0.35rem center / 0.4rem 0.5rem;
    padding-right: calc(var(--control-icon-size) + var(--control-padding-x));
  }

  /* Options */
  & option {
    /* On Windows with Chrome / Edge, options seems to use the same
    background color as the select. However for the dark theme the
    background is a semi-transparent white, resulting in an opaque white
    background for the dropdown. Use the modal background color to force
    a dark background instead. */
    background: var(--modal-container-bg-color);
  }
}

/* Form element: Checkbox and Radio */
.form-checkbox,
.form-radio,
.form-switch {
  display: block;
  line-height: var(--line-height);
  margin: calc((var(--control-size) - var(--control-size-sm)) / 2) 0;
  min-height: var(--control-size-sm);
  padding: calc((var(--control-size-sm) - var(--line-height)) / 2)
    var(--control-padding-x)
    calc((var(--control-size-sm) - var(--line-height)) / 2)
    calc(var(--control-icon-size) + var(--control-padding-x));
  position: relative;

  input {
    opacity: 0;
    position: absolute;
    top: calc((var(--control-size-sm) - var(--control-icon-size)) / 2);
    left: 0;
    height: var(--control-icon-size);
    width: var(--control-icon-size);
    cursor: pointer;

    &:focus-visible + .form-icon {
      outline: var(--focus-outline);
      outline-offset: var(--focus-outline-offset);
    }

    &:checked + .form-icon {
      background: var(--checkbox-checked-bg-color);
      border-color: var(--checkbox-checked-bg-color);
    }
  }

  .form-icon {
    pointer-events: none;
    border: var(--border-width) solid var(--checkbox-border-color);
    box-shadow: var(--input-box-shadow);
    display: inline-block;
    position: absolute;
    transition:
      background 0.2s,
      border 0.2s,
      color 0.2s;
  }

  /* Input checkbox, radio, and switch sizes */

  &.input-sm {
    font-size: var(--font-size-sm);
    margin: 0;
  }

  &.input-lg {
    font-size: var(--font-size-lg);
    margin: calc((var(--control-size-lg) - var(--control-size-sm)) / 2) 0;
  }
}

.form-checkbox,
.form-radio {
  .form-icon {
    background: var(--checkbox-bg-color);
    height: var(--control-icon-size);
    left: 0;
    top: calc((var(--control-size-sm) - var(--control-icon-size)) / 2);
    width: var(--control-icon-size);
  }
}

.form-checkbox {
  font-weight: 500;

  .form-icon {
    border-radius: var(--border-radius);
  }

  input {
    &:checked + .form-icon {
      &::before {
        background-clip: padding-box;
        border: var(--border-width-lg) solid var(--checkbox-icon-color);
        border-left-width: 0;
        border-top-width: 0;
        content: "";
        height: 9px;
        left: 50%;
        margin-left: -3px;
        margin-top: -6px;
        position: absolute;
        top: 50%;
        transform: rotate(45deg);
        width: 6px;
      }
    }

    &:indeterminate + .form-icon {
      background: var(--checkbox-checked-bg-color);
      border-color: var(--checkbox-checked-bg-color);

      &::before {
        background: var(--checkbox-icon-color);
        content: "";
        height: 2px;
        left: 50%;
        margin-left: -5px;
        margin-top: -1px;
        position: absolute;
        top: 50%;
        width: 10px;
      }
    }
  }
}

.form-radio {
  .form-icon {
    border-radius: 50%;
  }

  input {
    &:checked + .form-icon {
      &::before {
        background: var(--checkbox-icon-color);
        border-radius: 50%;
        content: "";
        height: 6px;
        left: 50%;
        position: absolute;
        top: 50%;
        transform: translate(-50%, -50%);
        width: 6px;
      }
    }
  }
}

/* Form element: Switch */
.form-switch {
  padding-left: calc(var(--unit-8) + var(--control-padding-x));

  .form-icon {
    background: var(--switch-bg-color);
    background-clip: padding-box;
    border-color: var(--switch-border-color);
    border-radius: calc(var(--unit-2) + var(--border-width));
    height: calc(var(--unit-4) + var(--border-width) * 2);
    left: 0;
    top: calc(
      (var(--control-size-sm) - var(--unit-4)) / 2 - var(--border-width)
    );
    width: var(--unit-8);

    &::before {
      background: var(--switch-toggle-color);
      border-radius: 50%;
      content: "";
      display: block;
      height: var(--unit-4);
      left: 0;
      position: absolute;
      top: 0;
      transition:
        background 0.2s,
        border 0.2s,
        color 0.2s,
        left 0.2s;
      width: var(--unit-4);
    }
  }

  input {
    &:checked + .form-icon {
      &::before {
        left: 14px;
      }
    }
  }
}

/* Form Icons */
.has-icon-left,
.has-icon-right {
  position: relative;

  .form-icon {
    height: var(--control-icon-size);
    margin: 0 var(--control-padding-y);
    position: absolute;
    top: 50%;
    transform: translateY(-50%);
    width: var(--control-icon-size);
    z-index: calc(var(--zindex-0) + 1);
  }
}

.has-icon-left {
  & .form-icon {
    left: var(--border-width);
  }

  & .form-input {
    padding-left: calc(var(--control-icon-size) + var(--control-padding-y) * 2);
  }
}

.has-icon-right {
  & .form-icon {
    right: var(--border-width);
  }

  & .form-input {
    padding-right: calc(
      var(--control-icon-size) + var(--control-padding-y) * 2
    );
  }
}

/* Form element: Input groups */
.input-group {
  display: flex;
  border-radius: var(--border-radius);
  box-shadow: var(--input-box-shadow);

  > * {
    box-shadow: none !important;
  }

  .input-group-addon {
    display: flex;
    align-items: center;
    background: var(--input-bg-color);
    border: var(--border-width) solid var(--input-border-color);
    border-radius: var(--border-radius);
    line-height: var(--line-height);
    padding: 0 var(--control-padding-x);
    white-space: nowrap;

    &.addon-sm {
      font-size: var(--font-size-sm);
      padding: var(--control-padding-y-sm) var(--control-padding-x-sm);
    }

    &.addon-lg {
      font-size: var(--font-size-lg);
      padding: var(--control-padding-y-lg) var(--control-padding-x-lg);
    }
  }

  .form-input,
  .form-select {
    flex: 1 1 auto;
    width: 1%;
  }

  .input-group-btn {
    z-index: var(--zindex-0);
  }

  .form-input,
  .form-select,
  .input-group-addon,
  .input-group-btn {
    &:first-child:not(:last-child) {
      border-bottom-right-radius: 0;
      border-top-right-radius: 0;
    }

    &:not(:first-child):not(:last-child) {
      border-radius: 0;
      margin-left: calc(-1 * var(--border-width));
    }

    &:last-child:not(:first-child) {
      border-bottom-left-radius: 0;
      border-top-left-radius: 0;
      margin-left: calc(-1 * var(--border-width));
    }

    &:focus {
      z-index: calc(var(--zindex-0) + 1);
    }
  }

  .form-select {
    width: auto;
  }

  &.input-inline {
    display: inline-flex;
  }
}

/* Form validation states */
.form-input,
.form-select {
  .has-success &,
  &.is-success {
    background: var(--success-color-shade);
    border-color: var(--success-color);

    &:focus {
      outline-color: var(--success-color);
    }
  }

  .has-error &,
  &.is-error {
    background: var(--error-color-shade);
    border-color: var(--error-color);

    &:focus {
      outline-color: var(--error-color);
    }
  }
}

/* Form disabled and readonly */
.form-input,
.form-select {
  &:disabled,
  &.disabled {
    background-color: var(--input-disabled-bg-color);
    cursor: not-allowed;
  }
}

input {
  &:disabled,
  &.disabled {
    & + .form-icon {
      background: var(--checkbox-disabled-bg-color);
      cursor: not-allowed;
    }
  }
}

/* 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;
  }
}


================================================
FILE: bookmarks/styles/theme/menus.css
================================================
:root {
  --menu-bg-color: var(--body-color);
  --menu-border-color: var(--gray-200);
  --menu-border-radius: var(--border-radius);
  --menu-box-shadow: var(--box-shadow);
  --menu-item-color: var(--text-color);
  --menu-item-hover-color: var(--primary-text-color);
  --menu-item-bg-color: transparent;
  --menu-item-hover-bg-color: var(--primary-color-shade);
  --menu-item-min-width: 120px;
}

/* Menus */
.menu {
  background: var(--menu-bg-color);
  border: solid 1px var(--menu-border-color);
  border-radius: var(--menu-border-radius);
  box-shadow: var(--menu-box-shadow);
  list-style: none;
  margin: 0;
  min-width: var(--menu-item-min-width);
  transform: translateY(var(--layout-spacing-sm));
  z-index: var(--zindex-3);

  &.menu-nav {
    background: transparent;
    box-shadow: none;
  }

  .menu-item {
    margin-top: 0;
    padding: 0 var(--unit-3);
    position: relative;
    text-decoration: none;
    white-space: nowrap;

    &:first-of-type {
      padding-top: var(--unit-1);
    }

    &:last-of-type {
      padding-bottom: var(--unit-1);
    }

    & > a,
    .btn.btn-link {
      border-radius: var(--menu-border-radius);
      color: var(--menu-item-color);
      background: var(--menu-item-bg-color);
      display: block;
      margin: 0 calc(-1 * var(--unit-2));
      padding: var(--unit-1) var(--unit-2);
      text-decoration: none;

      &:focus,
      &:hover,
      &:active,
      &.active {
        background: var(--menu-item-hover-bg-color);
        color: var(--menu-item-hover-color);
      }
    }

    .form-checkbox,
    .form-radio,
    .form-switch {
      margin: var(--unit-h) 0;
    }

    & + .menu-item {
      margin-top: var(--unit-1);
    }
  }

  & .menu-badge {
    align-items: center;
    display: flex;
    height: 100%;
    position: absolute;
    right: 0;
    top: 0;

    .label {
      margin-right: var(--unit-2);
    }
  }

  & .divider {
    border-bottom: solid 1px var(--secondary-border-color);
    margin: var(--unit-2) 0;
  }

  &.with-arrow {
    overflow: visible;
    --arrow-size: 16px;

    .menu-arrow {
      display: block;
      position: absolute;
      top: 0;
      width: var(--arrow-size);
      height: var(--arrow-size);
      translate: 0 -50%;
      rotate: 45deg;
      background: inherit;
      border: inherit;
      clip-path: polygon(0 0, 0 100%, 100% 0);
    }

    &.top-aligned .menu-arrow {
      top: auto;
      bottom: 0;
      rotate: 225deg;
      translate: 0 50%;
    }
  }
}


================================================
FILE: bookmarks/styles/theme/modals.css
================================================
/* Modals */
:root {
  --modal-overlay-bg-color: rgba(243, 244, 246, 0.6);
  --modal-container-bg-color: var(--body-color);
  --modal-container-border-color: var(--gray-200);
  --modal-border-radius: var(--border-radius-lg);
  --modal-box-shadow: var(--box-shadow-lg);
}

.modal {
  align-items: center;
  bottom: 0;
  display: none;
  justify-content: center;
  left: 0;
  opacity: 0;
  overflow: hidden;
  padding: var(--layout-spacing);
  position: fixed;
  right: 0;
  top: 0;

  &:target,
  &.active {
    display: flex;
    opacity: 1;
    z-index: var(--zindex-4);

    & .modal-overlay {
      animation: fade-in 0.15s ease 1;
      background: var(--modal-overlay-bg-color);
      bottom: 0;
      cursor: default;
      display: block;
      left: 0;
      position: fixed;
      right: 0;
      top: 0;
    }

    & .modal-container {
      animation: fade-in 0.15s ease 1;
      z-index: var(--zindex-0);
    }
  }

  &.active.closing {
    & .modal-overlay,
    & .modal-container {
      animation: fade-out 0.15s ease 1;
    }
  }
}

.modal-container {
  background: var(--modal-container-bg-color);
  border: solid 1px var(--modal-container-border-color);
  border-radius: var(--modal-border-radius);
  box-shadow: var(--modal-box-shadow);
  display: flex;
  flex-direction: column;
  gap: var(--unit-4);
  max-height: 75vh;
  max-width: var(--control-width-md);

  & .modal-header {
    display: flex;
    align-items: flex-start;
    gap: var(--unit-2);
    padding: var(--unit-6);
    padding-bottom: 0;
    color: var(--text-color);

    & h2 {
      flex: 1 1 0;
      align-items: flex-start;
      font-size: 1rem;
      margin: 0;
    }

    & .close {
      padding: 0;
      height: auto;
    }
  }

  & .modal-body {
    overflow-y: auto;
    padding: 0 var(--unit-6);
  }

  & .modal-body:not(:has(+ .modal-footer)) {
    margin-bottom: var(--unit-6);
  }

  & .modal-footer {
    padding: var(--unit-6);
    padding-top: 0;
  }
}

.modal.drawer {
  display: block;

  & .modal-container {
    position: fixed;
    top: 0;
    right: 0;
    width: 400px;
    max-width: 100%;
    height: 100%;
    max-height: 100%;
    border: none;
    border-left: solid 1px var(--modal-container-border-color);
    border-radius: 0;
    transform: translateX(100%);
    animation: fade-in 0.25s ease 1;
    transition: transform 0.25s ease;
  }

  &.active {
    & .modal-container {
      transform: translateX(0);
    }
  }

  &.active.closing {
    & .modal-container {
      animation: fade-out 0.25s ease 1;
      transform: translateX(100%);
    }
  }
}

.scroll-lock {
  overflow: hidden !important;
}


================================================
FILE: bookmarks/styles/theme/pagination.css
================================================
/* Pagination */
.pagination {
  display: flex;
  list-style: none;
  margin: var(--unit-1) 0;
  padding: var(--unit-1) 0;

  & .page-item {
    margin: var(--unit-1) var(--unit-o);

    & span {
      display: inline-block;
      padding: var(--unit-1) var(--unit-1);
    }

    & a {
      border-radius: var(--border-radius);
      display: inline-block;
      padding: var(--unit-1) var(--unit-2);
      text-decoration: none;

      &:focus,
      &:hover {
        color: var(--primary-text-color);
      }
    }

    &.disabled {
      & a {
        cursor: default;
        opacity: 0.5;
        pointer-events: none;
      }
    }

    &:first-child a {
      /* Remove left padding from first pagination link */
      padding-left: 0;
    }

    &.active {
      & a {
        background: var(--primary-color);
        color: var(--contrast-text-color);
      }
    }

    &.page-prev,
    &.page-next {
      flex: 1 0 50%;
    }

    &.page-next {
      text-align: right;
    }

    & .page-item-title {
      margin: 0;
    }

    & .page-item-subtitle {
      margin: 0;
      opacity: 0.5;
    }
  }
}


================================================
FILE: bookmarks/styles/theme/tables.css
================================================
/* Tables */
.table {
  border-collapse: collapse;
  border-spacing: 0;
  width: 100%;
  text-align: left;

  td,
  th {
    border-bottom: var(--border-width) solid var(--secondary-border-color);
    padding: var(--unit-2) var(--unit-2);
  }

  th {
    font-weight: 500;
    border-bottom-color: var(--border-color);
  }

  th:first-child,
  td:first-child {
    padding-left: 0;
  }
}


================================================
FILE: bookmarks/styles/theme/tabs.css
================================================
/* Tabs */
:root {
  --tab-color: var(--text-color);
  --tab-hover-color: var(--primary-text-color);
  --tab-active-color: var(--primary-text-color);
  --tab-highlight-color: var(--primary-color);
}

.tab {
  align-items: center;
  border-bottom: var(--border-width) solid var(--border-color);
  display: flex;
  flex-wrap: wrap;
  list-style: none;
  margin: var(--unit-1) 0 calc(var(--unit-1) - var(--border-width)) 0;

  & .tab-item {
    margin-top: 0;

    & a {
      border-bottom: var(--border-width-lg) solid transparent;
      color: var(--tab-color);
      display: block;
      margin: 0 var(--unit-2) 0 0;
      padding: var(--unit-2) var(--unit-1)
        calc(var(--unit-2) - var(--border-width-lg)) var(--unit-1);
      text-decoration: none;

      &:focus,
      &:hover {
        color: var(--tab-hover-color);
      }
    }

    &.active a,
    & a.active {
      border-bottom-color: var(--tab-highlight-color);
      color: var(--tab-active-color);
    }

    &.tab-action {
      flex: 1 0 auto;
      text-align: right;
    }

    & .btn-clear {
      margin-top: calc(-1 * var(--unit-1));
    }
  }

  &.tab-block {
    & .tab-item {
      flex: 1 0 0;
      text-align: center;

      & a {
        margin: 0;
      }

      & .badge {
        &[data-badge]::after {
          position: absolute;
          right: var(--unit-h);
          top: var(--unit-h);
          transform: translate(0, 0);
        }
      }
    }
  }

  &:not(.tab-block) {
    & .badge {
      padding-right: 0;
    }
  }
}


================================================
FILE: bookmarks/styles/theme/toasts.css
================================================
/* Toasts */
.toast {
  background: var(--gray-600);
  border-radius: var(--border-radius);
  color: var(--contrast-text-color);
  display: block;
  padding: var(--layout-spacing);
  width: 100%;

  &.toast-primary {
    background: var(--primary-color);
  }

  &.toast-success {
    background: var(--success-color);
  }

  &.toast-warning {
    background: var(--warning-color);
  }

  &.toast-error {
    background: var(--error-color);
  }

  .btn-clear {
    margin: var(--unit-h);
  }

  p {
    &:last-child {
      margin-bottom: 0;
    }
  }
}


================================================
FILE: bookmarks/styles/theme/typography.css
================================================
/* Typography */
/* Headings */
h1,
h2,
h3,
h4,
h5,
h6 {
  color: inherit;
  font-weight: 500;
  line-height: 1.2;
  margin-bottom: 0.5em;
  margin-top: 0;
}
.h1,
.h2,
.h3,
.h4,
.h5,
.h6 {
  font-weight: 500;
}
h1,
.h1 {
  font-size: 2rem;
}
h2,
.h2 {
  font-size: 1.6rem;
}
h3,
.h3 {
  font-size: 1.4rem;
}
h4,
.h4 {
  font-size: 1.2rem;
}
h5,
.h5 {
  font-size: 1rem;
}
h6,
.h6 {
  font-size: 0.8rem;
}

/* Paragraphs */
p {
  margin: 0 0 var(--line-height);
}

/* Semantic text elements */
a,
ins,
u {
  text-decoration-skip-ink: auto;
}

abbr[title] {
  border-bottom: var(--border-width) dotted;
  cursor: help;
  text-decoration: none;
}

/* Blockquote */
blockquote {
  border-left: var(--border-width-lg) solid var(--border-color);
  margin-left: 0;
  padding: var(--unit-2) var(--unit-4);

  & p:last-child {
    margin-bottom: 0;
  }
}

/* Lists */
ul,
ol {
  margin: var(--unit-4) 0 var(--unit-4) var(--unit-4);
  padding: 0;

  & ul,
  & ol {
    margin: var(--unit-4) 0 var(--unit-4) var(--unit-4);
  }

  & li {
    margin-top: var(--unit-2);
  }
}

ul {
  list-style: disc inside;

  & ul {
    list-style-type: circle;
  }
}

ol {
  list-style: decimal inside;

  & ol {
    list-style-type: lower-alpha;
  }
}

dl {
  & dt {
    font-weight: bold;
  }

  & dd {
    margin: var(--unit-1) 0 var(--unit-4) 0;
  }
}


================================================
FILE: bookmarks/styles/theme/utilities.css
================================================
/* Colors */
.text-primary {
  color: var(--primary-text-color);
}

.text-secondary {
  color: var(--secondary-text-color);
}

.text-tertiary {
  color: var(--tertiary-text-color);
}

.text-success {
  color: var(--success-color);
}

.text-warning {
  color: var(--warning-color);
}

.text-error {
  color: var(--error-color);
}

.icon-color {
  color: var(--icon-color);
}

/* Display */
.d-block {
  display: block;
}

.d-inline {
  display: inline;
}

.d-inline-block {
  display: inline-block;
}

.d-flex {
  display: flex;
}

.d-inline-flex {
  display: inline-flex;
}

.d-none,
.d-hide {
  display: none !important;
}

.d-visible {
  visibility: visible;
}

.d-invisible {
  visibility: hidden;
}

.text-hide {
  background: transparent;
  border: 0;
  color: transparent;
  font-size: 0;
  line-height: 0;
  text-shadow: none;
}

.text-assistive {
  border: 0;
  clip: rect(0, 0, 0, 0);
  height: 1px;
  margin: -1px;
  overflow: hidden;
  padding: 0;
  position: absolute;
  width: 1px;
}

/* Loading */
.loading {
  color: transparent !important;
  min-height: var(--unit-4);
  pointer-events: none;
  position: relative;

  &::after {
    animation: loading 500ms infinite linear;
    background: transparent;
    border: var(--border-width-lg) solid var(--primary-color);
    border-radius: 50%;
    border-right-color: transparent;
    border-top-color: transparent;
    content: "";
    display: block;
    height: var(--unit-4);
    left: 50%;
    margin-left: calc(-1 * var(--unit-2));
    margin-top: calc(-1 * var(--unit-2));
    opacity: 1;
    padding: 0;
    position: absolute;
    top: 50%;
    width: var(--unit-4);
    z-index: var(--zindex-0);
  }

  &.loading-lg {
    min-height: var(--unit-10);

    &::after {
      height: var(--unit-8);
      margin-left: calc(-1 * var(--unit-4));
      margin-top: calc(-1 * var(--unit-4));
      width: var(--unit-8);
    }
  }
}

/* Position */
.m-0 {
  margin: 0 !important;
}

.mb-0 {
  margin-bottom: 0 !important;
}

.ml-0 {
  margin-left: 0 !important;
}

.mr-0 {
  margin-right: 0 !important;
}

.mt-0 {
  margin-top: 0 !important;
}

.mx-0 {
  margin-left: 0 !important;
  margin-right: 0 !important;
}

.my-0 {
  margin-bottom: 0 !important;
  margin-top: 0 !important;
}

.m-1 {
  margin: var(--unit-1) !important;
}

.mb-1 {
  margin-bottom: var(--unit-1) !important;
}

.ml-1 {
  margin-left: var(--unit-1) !important;
}

.mr-1 {
  margin-right: var(--unit-1) !important;
}

.mt-1 {
  margin-top: var(--unit-1) !important;
}

.mx-1 {
  margin-left: var(--unit-1) !important;
  margin-right: var(--unit-1) !important;
}

.my-1 {
  margin-bottom: var(--unit-1) !important;
  margin-top: var(--unit-1) !important;
}

.m-2 {
  margin: var(--unit-2) !important;
}

.mb-2 {
  margin-bottom: var(--unit-2) !important;
}

.ml-2 {
  margin-left: var(--unit-2) !important;
}

.mr-2 {
  margin-right: var(--unit-2) !important;
}

.mt-2 {
  margin-top: var(--unit-2) !important;
}

.mx-2 {
  margin-left: var(--unit-2) !important;
  margin-right: var(--unit-2) !important;
}

.my-2 {
  margin-bottom: var(--unit-2) !important;
  margin-top: var(--unit-2) !important;
}

.m-4 {
  margin: var(--unit-4) !important;
}

.mb-4 {
  margin-bottom: var(--unit-4) !important;
}

.ml-4 {
  margin-left: var(--unit-4) !important;
}

.mr-4 {
  margin-right: var(--unit-4) !important;
}

.mt-4 {
  margin-top: var(--unit-4) !important;
}

.mx-4 {
  margin-left: var(--unit-4) !important;
  margin-right: var(--unit-4) !important;
}

.my-4 {
  margin-bottom: var(--unit-4) !important;
  margin-top: var(--unit-4) !important;
}

.m-6 {
  margin: var(--unit-6) !important;
}

.mb-6 {
  margin-bottom: var(--unit-6) !important;
}

.ml-6 {
  margin-left: var(--unit-6) !important;
}

.mr-6 {
  margin-right: var(--unit-6) !important;
}

.mt-6 {
  margin-top: var(--unit-6) !important;
}

.mx-6 {
  margin-left: var(--unit-6) !important;
  margin-right: var(--unit-6) !important;
}

.my-6 {
  margin-bottom: var(--unit-6) !important;
  margin-top: var(--unit-6) !important;
}

.ml-auto {
  margin-left: auto;
}

.mr-auto {
  margin-right: auto;
}

.mx-auto {
  margin-left: auto;
  margin-right: auto;
}

/* Text */
.text-normal {
  font-weight: normal;
}

.text-semibold {
  font-weight: 500;
}

.text-bold {
  font-weight: bold;
}

.text-italic {
  font-style: italic;
}

.text-large {
  font-size: 1.2em;
}

.text-small {
  font-size: 0.9em;
}

.text-tiny {
  font-size: 0.8em;
}

.text-muted {
  opacity: 0.8;
}

.truncate {
  white-space: nowrap;
  overflow: hidden;
  text-overflow: ellipsis;
}

/* Flex */
.flex-column {
  flex-direction: column;
}

.align-baseline {
  align-items: baseline;
}

.align-center {
  align-items: center;
}

.justify-between {
  justify-content: space-between;
}

.gap-2 {
  gap: var(--unit-2);
}


================================================
FILE: bookmarks/styles/theme/variables.css
================================================
:root {
  /* Color palette */
  --gray-50: rgb(249, 250, 251);
  --gray-100: rgb(243, 244, 246);
  --gray-200: rgb(229, 231, 235);
  --gray-300: rgb(209, 213, 219);
  --gray-400: rgb(156, 163, 175);
  --gray-500: rgb(107, 114, 128);
  --gray-600: rgb(75, 85, 99);
  --gray-700: rgb(55, 65, 81);
  --gray-800: rgb(31, 41, 55);
  --gray-900: rgb(17, 24, 39);

  --primary-color: hsl(241, 63%, 59%);
  --primary-color-highlight: hsl(241, 63%, 64%);
  --primary-color-shade: hsl(241, 63%, 59%, 0.075);

  --alternative-color: hsl(179, 94%, 29%);
  --alternative-color-dark: hsl(179, 94%, 22%);

  --success-color: hsl(142, 76%, 36%);
  --success-color-highlight: hsl(142, 76%, 40%);
  --success-color-shade: hsla(142, 76%, 36%, 0.1);

  --warning-color: hsl(38, 92%, 50%);
  --warning-color-highlight: hsl(38, 92%, 55%);
  --warning-color-shade: hsla(38, 92%, 50%, 0.1);

  --error-color: hsl(0, 72%, 51%);
  --error-color-highlight: hsl(0, 72%, 60%);
  --error-color-shade: hsla(0, 72%, 51%, 0.1);

  /* Core colors */
  --text-color: var(--gray-700);
  --secondary-text-color: var(--gray-500);
  --tertiary-text-color: var(--gray-500);
  --contrast-text-color: #fff;
  --primary-text-color: hsl(241, 63%, 55%);

  --link-color: var(--primary-text-color);
  --secondary-link-color: hsla(241, 63%, 54%, 0.8);

  --icon-color: var(--gray-500);

  --border-color: var(--gray-300);
  --secondary-border-color: var(--gray-200);

  --body-color: #fff;
  --body-color-contrast: var(--gray-100);

  /* Fonts */
  --base-font-family:
    -apple-system, system-ui, BlinkMacSystemFont, "Segoe UI", Roboto;
  --mono-font-family:
    "SF Mono", "Segoe UI Mono", "Roboto Mono", Menlo, Courier, monospace;
  --fallback-font-family: "Helvetica Neue", sans-serif;
  --cjk-zh-hans-font-family:
    var(--base-font-family), "PingFang SC", "Hiragino Sans GB",
    "Microsoft YaHei", var(--fallback-font-family);
  --cjk-zh-hant-font-family:
    var(--base-font-family), "PingFang TC", "Hiragino Sans CNS",
    "Microsoft JhengHei", var(--fallback-font-family);
  --cjk-jp-font-family:
    var(--base-font-family), "Hiragino Sans", "Hiragino Kaku Gothic Pro",
    "Yu Gothic", YuGothic, Meiryo, var(--fallback-font-family);
  --cjk-ko-font-family:
    var(--base-font-family), "Malgun Gothic", var(--fallback-font-family);
  --body-font-family: var(--base-font-family), var(--fallback-font-family);

  /* Unit sizes */
  --unit-o: 0.05rem;
  --unit-h: 0.1rem;
  --unit-1: 0.2rem;
  --unit-2: 0.4rem;
  --unit-3: 0.6rem;
  --unit-4: 0.8rem;
  --unit-5: 1rem;
  --unit-6: 1.2rem;
  --unit-7: 1.4rem;
  --unit-8: 1.6rem;
  --unit-9: 1.8rem;
  --unit-10: 2rem;
  --unit-12: 2.4rem;
  --unit-16: 3.2rem;

  /* Font sizes */
  --html-font-size: 20px;
  --html-line-height: 1.5;
  --font-size: 0.7rem;
  --font-size-sm: 0.65rem;
  --font-size-lg: 0.8rem;
  --font-size-xl: 1rem;
  --line-height: 1rem;

  /* Sizes */
  --layout-spacing: var(--unit-2);
  --layout-spacing-sm: var(--unit-1);
  --layout-spacing-lg: var(--unit-4);
  --border-radius: var(--unit-1);
  --border-radius-lg: var(--unit-2);
  --border-width: var(--unit-o);
  --border-width-lg: var(--unit-h);
  --control-size: var(--unit-8);
  --control-size-sm: var(--unit-6);
  --control-size-lg: var(--unit-9);
  --control-padding-x: var(--unit-2);
  --control-padding-x-sm: calc(var(--unit-2) * 0.75);
  --control-padding-x-lg: calc(var(--unit-2) * 1.5);
  --control-padding-y: calc(
    (var(--control-size) - var(--line-height)) / 2 - var(--border-width)
  );
  --control-padding-y-sm: calc(
    (var(--control-size-sm) - var(--line-height)) / 2 - var(--border-width)
  );
  --control-padding-y-lg: calc(
    (var(--control-size-lg) - var(--line-height)) / 2 - var(--border-width)
  );
  --control-icon-size: 0.8rem;

  --control-width-xs: 180px;
  --control-width-sm: 320px;
  --control-width-md: 640px;
  --control-width-lg: 960px;
  --control-width-xl: 1280px;

  /* Responsive breakpoints */
  --size-xs: 480px;
  --size-sm: 600px;
  --size-md: 840px;
  --size-lg: 960px;
  --size-xl: 1280px;
  --size-2x: 1440px;

  --responsive-breakpoint: var(--size-xs);

  /* Z-index */
  --zindex-0: 1;
  --zindex-1: 100;
  --zindex-2: 200;
  --zindex-3: 300;
  --zindex-4: 400;

  /* Focus */
  --focus-outline: 2px solid var(--primary-color);
  --focus-outline-offset: 2px;

  /* Shadows */
  --box-shadow-xs: rgba(0, 0, 0, 0.05) 0px 1px 2px 0px;
  --box-shadow: 0 1px 3px 0 rgb(0 0 0 / 0.1), 0 1px 2px -1px rgb(0 0 0 / 0.1);
  --box-shadow-lg:
    0 10px 15px -3px rgb(0 0 0 / 0.1), 0 4px 6px -4px rgb(0 0 0 / 0.1);
}


================================================
FILE: bookmarks/styles/theme-dark.css
================================================
@import "theme-light.css";

:root {
  /* Color palette */
  --contrast-5: hsla(241, 65%, 85%, 0.06);
  --contrast-10: hsla(241, 60%, 80%, 0.14);
  --contrast-20: hsla(241, 64%, 82%, 0.23);
  --contrast-30: hsla(241, 69%, 84%, 0.32);
  --contrast-40: hsla(241, 73%, 86%, 0.41);
  --contrast-50: hsla(241, 78%, 88%, 0.5);
  --contrast-60: hsla(241, 82%, 90%, 0.58);
  --contrast-70: hsla(241, 87%, 92%, 0.69);
  --contrast-80: hsla(241, 91%, 94%, 0.8);
  --contrast-90: hsla(241, 96%, 96%, 0.9);

  --primary-color: hsl(241, 75%, 64%);
  --primary-color-highlight: hsl(241, 75%, 68%);
  --primary-color-shade: hsl(241, 75%, 64%, 0.42);

  --alternative-color: hsl(179, 50%, 58%);
  --alternative-color-dark: hsl(179, 80%, 75%);

  --success-color: hsl(142, 76%, 36%);
  --success-color-highlight: hsl(142, 76%, 40%);
  --success-color-shade: hsla(142, 76%, 36%, 0.1);

  --warning-color: hsl(38, 92%, 50%);
  --warning-color-highlight: hsl(38, 92%, 55%);
  --warning-color-shade: hsla(38, 92%, 50%, 0.1);

  --error-color: hsl(0, 80%, 60%);
  --error-color-highlight: hsl(0, 72%, 60%);
  --error-color-shade: hsla(0, 72%, 51%, 0.1);

  /* Core colors */
  --text-color: var(--gray-300);
  --secondary-text-color: var(--gray-400);
  --tertiary-text-color: var(--gray-500);
  --contrast-text-color: #fff;
  --primary-text-color: hsl(241, 82%, 82%);

  --link-color: var(--primary-text-color);
  --secondary-link-color: hsla(241, 82%, 82%, 0.8);

  --icon-color: var(--text-color);

  --border-color: var(--contrast-30);
  --secondary-border-color: var(--contrast-20);

  --body-color: hsl(241, 15%, 14%);
  --body-color-contrast: var(--contrast-10);

  /* Focus */
  --focus-outline: 2px solid hsl(241, 100%, 78%);
  --focus-outline-offset: 2px;

  /* Shadows */
  --box-shadow-xs: none;
  --box-shadow: none;
  --box-shadow-lg: none;
}

:root {
  --input-bg-color: var(--contrast-5);
  --input-disabled-bg-color: var(--contrast-30);
  --input-text-color: var(--text-color);
  --input-hint-color: var(--secondary-text-color);
  --input-border-color: var(--border-color);
  --input-placeholder-color: var(--tertiary-text-color);
  --input-box-shadow: var(--box-shadow-xs);

  --checkbox-bg-color: var(--contrast-10);
  --checkbox-checked-bg-color: var(--primary-color);
  --checkbox-disabled-bg-color: var(--contrast-30);
  --checkbox-border-color: var(--border-color);
  --checkbox-icon-color: #fff;

  --switch-bg-color: var(--contrast-10);
  --switch-border-color: var(--border-color);
  --switch-toggle-color: var(--text-color);
}

:root {
  --btn-bg-color: var(--contrast-5);
  --btn-hover-bg-color: var(--contrast-20);
  --btn-border-color: var(--border-color);
  --btn-text-color: var(--text-color);
  --btn-icon-color: var(--icon-color);
  --btn-font-weight: 400;
  --btn-box-shadow: var(--box-shadow-xs);

  --btn-primary-bg-color: var(--primary-color);
  --btn-primary-hover-bg-color: var(--primary-color-highlight);
  --btn-primary-text-color: var(--contrast-text-color);

  --btn-success-bg-color: var(--success-color);
  --btn-success-hover-bg-color: var(--success-color-highlight);
  --btn-success-text-color: var(--contrast-text-color);

  --btn-error-bg-color: var(--error-color);
  --btn-error-hover-bg-color: var(--error-color-highlight);
  --btn-error-text-color: var(--contrast-text-color);

  --btn-link-text-color: var(--link-color);
  --btn-link-hover-text-color: var(--link-color);
}

:root {
  --modal-overlay-bg-color: hsla(229, 21%, 16%, 0.55);
  --modal-container-bg-color: hsl(241, 20%, 20%);
  --modal-container-border-color: var(--contrast-30);
  --modal-border-radius: var(--border-radius-lg);
  --modal-box-shadow: none;
}

:root {
  --menu-bg-color: hsl(241, 20%, 20%);
  --menu-border-color: var(--contrast-30);
  --menu-border-radius: var(--border-radius);
  --menu-box-shadow: none;
  --menu-item-color: var(--text-color);
  --menu-item-hover-color: var(--text-color);
  --menu-item-bg-color: transparent;
  --menu-item-hover-bg-color: var(--contrast-20);
}

:root {
  --tab-color: var(--text-color);
  --tab-hover-color: var(--primary-text-color);
  --tab-active-color: var(--primary-text-color);
  --tab-highlight-color: var(--primary-text-color);
}

:root {
  --bookmark-title-color: var(--primary-text-color);
  --bookmark-title-weight: 500;
  --bookmark-description-color: var(--text-color);
  --bookmark-description-weight: 400;
  --bookmark-actions-color: var(--secondary-text-color);
  --bookmark-actions-hover-color: var(--text-color);
  --bookmark-actions-weight: 400;
  --bulk-actions-bg-color: var(--contrast-5);
}

/* Try to force dark color scheme for all native elements (e.g. upload button
in file inputs, native select dropdown). For the select dropdown some browsers
ignore this and use whatever users have configured in their system settings. */
:root {
  color-scheme: dark;
}


================================================
FILE: bookmarks/styles/theme-light.css
================================================
@import "theme/variables.css";
@import "theme/_normalize.css";
@import "theme/base.css";
@import "theme/typography.css";
@import "theme/asian.css";
@import "theme/tables.css";
@import "theme/buttons.css";
@import "theme/forms.css";
@import "theme/code.css";
@import "theme/dropdowns.css";
@import "theme/menus.css";
@import "theme/badges.css";
@import "theme/empty.css";
@import "theme/modals.css";
@import "theme/pagination.css";
@import "theme/tabs.css";
@import "theme/toasts.css";
@import "theme/autocomplete.css";
@import "theme/animations.css";
@import "theme/utilities.css";

@import "responsive.css";
@import "layout.css";
@import "components.css";
@import "crud.css";
@import "bookmark-details.css";
@import "bookmark-form.css";
@import "bookmark-page.css";
@import "markdown.css";
@import "reader-mode.css";
@import "settings.css";
@import "bundles.css";
@import "tags.css";
@import "auth.css";


================================================
FILE: bookmarks/tasks.py
================================================
# Expose task modules to Huey Django extension
# noinspection PyUnusedImports
import bookmarks.services.tasks  # noqa: F401


================================================
FILE: bookmarks/templates/admin/background_tasks.html
================================================
{% extends "admin/base_site.html" %}
{% block content %}
  <table style="width: 100%">
    <thead>
      <tr>
        <th>ID</th>
        <th>Name</th>
        <th>Args</th>
        <th>Retries</th>
      </tr>
    </thead>
    <tbody>
      {% for task in tasks %}
        <tr>
          <td>{{ task.id }}</td>
          <td>{{ task.name }}</td>
          <td>{{ task.args }}</td>
          <td>{{ task.retries }}</td>
        </tr>
      {% endfor %}
    </tbody>
  </table>
  <p class="paginator">
    {% if page.paginator.num_pages > 1 %}
      {% for page_number in page_range %}
        {% if page_number == page.number %}
          <span class="this-page">{{ page_number }}</span>
        {% elif page_number == '…' %}
          <span>…</span>
        {% else %}
          <a href="?p={{ page_number }}">{{ page_number }}</a>
        {% endif %}
      {% endfor %}
      &nbsp;
    {% endif %}
    {{ page.paginator.count }} tasks
  </p>
{% endblock %}


================================================
FILE: bookmarks/templates/bookmarks/bookmark_list.html
================================================
{% load static shared pagination %}
{% if bookmark_list.is_empty %}
  {% include 'bookmarks/empty_bookmarks.html' %}
{% else %}
  <section aria-label="Bookmark list">
    <ul class="bookmark-list{% if bookmark_list.show_notes %} show-notes{% endif %}"
        role="list"
        tabindex="-1"
        style="--ld-bookmark-description-max-lines:{{ bookmark_list.description_max_lines }}"
        data-bookmarks-total="{{ bookmark_list.bookmarks_total }}">
      {% for bookmark_item in bookmark_list.items %}
        <li data-bookmark-id="{{ bookmark_item.id }}"
            role="listitem"
            {% if bookmark_item.css_classes %}class="{{ bookmark_item.css_classes }}"{% endif %}>
          <div class="content">
            <div class="title">
              {% if not bookmark_list.is_preview %}
                <label class="form-checkbox bulk-edit-checkbox">
                  <input type="checkbox" name="bookmark_id" value="{{ bookmark_item.id }}">
                  <i class="form-icon"></i>
                </label>
              {% endif %}
              {% if bookmark_item.favicon_file and bookmark_list.show_favicons %}
                <img class="favicon" src="{% static bookmark_item.favicon_file %}" alt="">
              {% endif %}
              <a href="{{ bookmark_item.url }}"
                 target="{{ bookmark_list.link_target }}"
                 rel="noopener">
                <span>{{ bookmark_item.title }}</span>
              </a>
            </div>
            {% if bookmark_list.show_url %}
              <div class="url-path truncate">
                <a href="{{ bookmark_item.url }}"
                   target="{{ bookmark_list.link_target }}"
                   rel="noopener"
                   class="url-display">{{ bookmark_item.url }}</a>
              </div>
            {% endif %}
            {% if bookmark_list.description_display == 'inline' %}
              <div class="description inline truncate">
                {% if bookmark_item.tags %}
                  <span class="tags">
                    {% for tag in bookmark_item.tags %}<a href="?{{ tag.query_string }}">#{{ tag.name }}</a>{% endfor %}
                  </span>
                {% endif %}
                {% if bookmark_item.tags and bookmark_item.description %}|{% endif %}
                {% if bookmark_item.description %}<span>{{ bookmark_item.description }}</span>{% endif %}
              </div>
            {% else %}
              {% if bookmark_item.description %}<div class="description separate">{{ bookmark_item.description }}</div>{% endif %}
              {% if bookmark_item.tags %}
                <div class="tags">
                  {% for tag in bookmark_item.tags %}<a href="?{{ tag.query_string }}">#{{ tag.name }}</a>{% endfor %}
                </div>
              {% endif %}
            {% endif %}
            {% if bookmark_item.notes %}
              <div class="notes">
                <div class="markdown">{% markdown bookmark_item.notes %}</div>
              </div>
            {% endif %}
            <div class="actions">
              {% if bookmark_item.display_date %}
                {% if bookmark_item.snapshot_url %}
                  <a href="{{ bookmark_item.snapshot_url }}"
                     title="{{ bookmark_item.snapshot_title }}"
                     target="{{ bookmark_list.link_target }}"
                     rel="noopener">{{ bookmark_item.display_date }}</a>
                {% else %}
                  <span>{{ bookmark_item.display_date }}</span>
                {% endif %}
                {% if not bookmark_list.is_preview %}<span>|</span>{% endif %}
              {% endif %}
              {% if not bookmark_list.is_preview %}
                {# View link is visible for both owned and shared bookmarks #}
                {% if bookmark_list.show_view_action %}
                  <a href="{{ bookmark_item.details_url }}"
                     class="view-action"
                     data-turbo-action="replace"
                     data-turbo-frame="details-modal">View</a>
                {% endif %}
                {% if bookmark_item.is_editable %}
                  {# Bookmark owner actions #}
                  {% if bookmark_list.show_edit_action %}
                    <a href="{% url 'linkding:bookmarks.edit' bookmark_item.id %}?return_url={{ bookmark_list.return_url|urlencode }}">Edit</a>
                  {% endif %}
                  {% if bookmark_list.show_archive_action %}
                    {% if bookmark_item.is_archived %}
                      <button type="submit"
                              name="unarchive"
                              value="{{ bookmark_item.id }}"
                              class="btn btn-link btn-sm">Unarchive</button>
                    {% else %}
                      <button type="submit"
                              name="archive"
                              value="{{ bookmark_item.id }}"
                              class="btn btn-link btn-sm">Archive</button>
                    {% endif %}
                  {% endif %}
                  {% if bookmark_list.show_remove_action %}
                    <button data-confirm
                            type="submit"
                            name="remove"
                            value="{{ bookmark_item.id }}"
                            class="btn btn-link btn-sm">Remove</button>
                  {% endif %}
                {% else %}
                  {# Shared bookmark actions #}
                  <span>Shared by
                    <a href="?{% replace_query_param user=bookmark_item.owner.username %}">{{ bookmark_item.owner.username }}</a>
                  </span>
                {% endif %}
                {% if bookmark_item.has_extra_actions %}
                  <div class="extra-actions">
                    <span class="hide-sm">|</span>
                    {% if bookmark_item.show_mark_as_read %}
                      <button type="submit"
                              name="mark_as_read"
                              value="{{ bookmark_item.id }}"
                              class="btn btn-link btn-sm btn-icon"
                              data-confirm
                              data-confirm-question="Mark as read?">
                        <svg width="16" height="16">
                          <use href="{% static 'icons.svg' %}?v={{ app_version }}#unread"></use>
                        </svg>
                        Unread
                      </button>
                    {% endif %}
                    {% if bookmark_item.show_unshare %}
                      <button type="submit"
                              name="unshare"
                              value="{{ bookmark_item.id }}"
                              class="btn btn-link btn-sm btn-icon"
                              data-confirm
                              data-confirm-question="Unshare?">
                        <svg width="16" height="16">
                          <use href="{% static 'icons.svg' %}?v={{ app_version }}#share"></use>
                        </svg>
                        Shared
                      </button>
                    {% endif %}
                    {% if bookmark_item.show_notes_button %}
                      <button type="button" class="btn btn-link btn-sm btn-icon toggle-notes">
                        <svg width="16" height="16">
                          <use href="{% static 'icons.svg' %}?v={{ app_version }}#note"></use>
                        </svg>
                        Notes
                      </button>
                    {% endif %}
                  </div>
                {% endif %}
              {% endif %}
            </div>
          </div>
          {% if bookmark_list.show_preview_images %}
            {% if bookmark_item.preview_image_file %}
              <img class="preview-image"
                   src="{% static bookmark_item.preview_image_file %}"
                   alt=""
                   loading="lazy" />
            {% else %}
              <div class="preview-image placeholder">
                <div class="img" /></div>
            {% endif %}
          {% endif %}
        </li>
      {% endfor %}
    </ul>
    <div class="bookmark-pagination{% if request.user_profile.sticky_pagination %} sticky{% endif %}">
      {% pagination bookmark_list.bookmarks_page %}
    </div>
  </section>
{% endif %}
<script>
  document.dispatchEvent(new CustomEvent('bookmark-list-updated'));
</script>


================================================
FILE: bookmarks/templates/bookmarks/bookmark_page.html
================================================
{% extends "shared/layout.html" %}
{% load static shared bookmarks %}
{% block content %}
  <ld-bookmark-page {% if not bookmark_list.bulk_edit_enabled %}no-bulk-edit{% endif %}
                    class="bookmarks-page grid columns-md-1 {% if bookmark_list.collapse_side_panel %}collapse-side-panel{% endif %}">
    {# Bookmark list #}
    <main class="main col-2" aria-labelledby="main-heading">
      <div class="section-header {% if bookmark_list.bulk_edit_enabled %}mb-0{% endif %}">
        <h1 id="main-heading">{{ bookmark_list.list_title }}</h1>
        <div class="header-controls">
          {% bookmark_search bookmark_list.search mode=bookmark_list.search_mode %}
          {% if bookmark_list.bulk_edit_enabled %}
            <button class="btn hide-sm ml-2 bulk-edit-active-toggle" title="Bulk edit">
              <svg width="20px" height="20px">
                <use href="{% static 'icons.svg' %}?v={{ app_version }}#bulk-edit"></use>
              </svg>
            </button>
          {% endif %}
          <ld-filter-drawer-trigger>
            <button class="btn ml-2">Filters</button>
          </ld-filter-drawer-trigger>
        </div>
      </div>
      <form class="bookmark-actions"
            action="{{ bookmark_list.action_url|safe }}"
            method="post"
            autocomplete="off">
        {% csrf_token %}
        {% if bookmark_list.bulk_edit_enabled %}
          {% include 'bookmarks/bulk_edit_bar.html' %}
        {% endif %}
        <div id="bookmark-list-container">{% include 'bookmarks/bookmark_list.html' %}</div>
      </form>
    </main>
    {# Filters #}
    <div class="side-panel col-1 hide-md">
      {% if bundles %}
        {% include 'bookmarks/bundle_section.html' %}
      {% endif %}
      {% if user_list %}
        {% include 'bookmarks/user_section.html' %}
      {% endif %}
      {% include 'bookmarks/tag_section.html' %}
    </div>
  </ld-bookmark-page>
{% endblock %}
{% block overlays %}
  {% include 'bookmarks/details/modal.html' %}
{% endblock %}


================================================
FILE: bookmarks/templates/bookmarks/bulk_edit_bar.html
================================================
{% load shared %}
{% htmlmin %}
<div class="bulk-edit-bar">
  <label class="form-checkbox bulk-edit-checkbox all">
    <input type="checkbox">
    <i class="form-icon"></i>
  </label>
  <select name="bulk_action" class="form-select select-sm">
    {% if not 'bulk_archive' in bookmark_list.bulk_edit_disabled_actions %}
      <option value="bulk_archive">Archive</option>
    {% endif %}
    {% if not 'bulk_unarchive' in bookmark_list.bulk_edit_disabled_actions %}
      <option value="bulk_unarchive">Unarchive</option>
    {% endif %}
    <option value="bulk_delete">Delete</option>
    <option value="bulk_tag">Add tags</option>
    <option value="bulk_untag">Remove tags</option>
    <option value="bulk_read">Mark as read</option>
    <option value="bulk_unread">Mark as unread</option>
    {% if request.user_profile.enable_sharing %}
      <option value="bulk_share">Share</option>
      <option value="bulk_unshare">Unshare</option>
    {% endif %}
    <option value="bulk_refresh">Refresh from website</option>
    {% if bookmark_list.snapshot_feature_enabled %}<option value="bulk_snapshot">Create HTML snapshot</option>{% endif %}
  </select>
  <ld-tag-autocomplete input-name="bulk_tag_string"
                       input-placeholder="Tag names..."
                       variant="small">
  </ld-tag-autocomplete>
  <button data-confirm
          type="submit"
          name="bulk_execute"
          class="btn btn-link btn-sm">
    <span>Execute</span>
  </button>
  <label class="form-checkbox select-across d-none">
    <input type="checkbox" name="bulk_select_across">
    <i class="form-icon"></i>
    All <span class="total">{{ bookmark_list.bookmarks_total }}</span> bookmarks
  </label>
</div>
{% endhtmlmin %}


================================================
FILE: bookmarks/templates/bookmarks/bundle_section.html
================================================
{% load static %}
{% if not request.user_profile.hide_bundles %}
  <section aria-labelledby="bundles-heading">
    <div class="section-header no-wrap">
      <h2 id="bundles-heading">Bundles</h2>
      <ld-dropdown class="dropdown dropdown-right ml-auto">
        <button class="btn btn-noborder dropdown-toggle" aria-label="Bundles menu">
          <svg width="20" height="20">
            <use href="{% static 'icons.svg' %}?v={{ app_version }}#menu"></use>
          </svg>
        </button>
        <ul class="menu" role="list" tabindex="-1">
          <li class="menu-item">
            <a href="{% url 'linkding:bundles.index' %}" class="menu-link">Manage bundles</a>
          </li>
          {% if bookmark_list.search.q %}
            <li class="menu-item">
              <a href="{% url 'linkding:bundles.new' %}?q={{ bookmark_list.search.q|urlencode }}"
                 class="menu-link">Create
              bundle from search</a>
            </li>
          {% endif %}
        </ul>
      </ld-dropdown>
    </div>
    <ul class="bundle-menu">
      {% for bundle in bundles.bundles %}
        <li class="bundle-menu-item {% if bundle.id == bundles.selected_bundle.id %}selected{% endif %}">
          <a href="?bundle={{ bundle.id }}">{{ bundle.name }}</a>
        </li>
      {% endfor %}
    </ul>
  </section>
{% endif %}


================================================
FILE: bookmarks/templates/bookmarks/close.html
================================================
{% extends "shared/layout.html" %}
{% block content %}
  <script type="application/javascript">
    window.close()
  </script>
  <p>You can now close this window.</p>
{% endblock %}


================================================
FILE: bookmarks/templates/bookmarks/details/asset_icon.html
================================================
{% if asset.content_type == 'text/html' %}
  <svg xmlns="http://www.w3.org/2000/svg"
       width="24"
       height="24"
       viewBox="0 0 24 24"
       fill="none"
       stroke="currentColor"
       stroke-width="2"
       stroke-linecap="round"
       stroke-linejoin="round">
    <path stroke="none" d="M0 0h24v24H0z" fill="none" />
    <path d="M14 3v4a1 1 0 0 0 1 1h4" />
    <path d="M5 12v-7a2 2 0 0 1 2 -2h7l5 5v4" />
    <path d="M2 21v-6" />
    <path d="M5 15v6" />
    <path d="M2 18h3" />
    <path d="M20 15v6h2" />
    <path d="M13 21v-6l2 3l2 -3v6" />
    <path d="M7.5 15h3" />
    <path d="M9 15v6" />
  </svg>
{% elif asset.content_type == 'application/pdf' %}
  <svg xmlns="http://www.w3.org/2000/svg"
       width="24"
       height="24"
       viewBox="0 0 24 24"
       fill="none"
       stroke="currentColor"
       stroke-width="2"
       stroke-linecap="round"
       stroke-linejoin="round">
    <path stroke="none" d="M0 0h24v24H0z" fill="none" />
    <path d="M14 3v4a1 1 0 0 0 1 1h4" />
    <path d="M5 12v-7a2 2 0 0 1 2 -2h7l5 5v4" />
    <path d="M5 18h1.5a1.5 1.5 0 0 0 0 -3h-1.5v6" />
    <path d="M17 18h2" />
    <path d="M20 15h-3v6" />
    <path d="M11 15v6h1a2 2 0 0 0 2 -2v-2a2 2 0 0 0 -2 -2h-1z" />
  </svg>
{% elif asset.content_type == 'image/png' or asset.content_type == 'image/jpeg' or asset.content_type == 'image.gif' %}
  <svg xmlns="http://www.w3.org/2000/svg"
       width="24"
       height="24"
       viewBox="0 0 24 24"
       fill="none"
       stroke="currentColor"
       stroke-width="2"
       stroke-linecap="round"
       stroke-linejoin="round">
    <path stroke="none" d="M0 0h24v24H0z" fill="none" />
    <path d="M15 8h.01" />
    <path d="M3 6a3 3 0 0 1 3 -3h12a3 3 0 0 1 3 3v12a3 3 0 0 1 -3 3h-12a3 3 0 0 1 -3 -3v-12z" />
    <path d="M3 16l5 -5c.928 -.893 2.072 -.893 3 0l5 5" />
    <path d="M14 14l1 -1c.928 -.893 2.072 -.893 3 0l3 3" />
  </svg>
{% else %}
  <svg xmlns="http://www.w3.org/2000/svg"
       width="24"
       height="24"
       viewBox="0 0 24 24"
       fill="none"
       stroke="currentColor"
       stroke-width="2"
       stroke-linecap="round"
       stroke-linejoin="round">
    <path stroke="none" d="M0 0h24v24H0z" fill="none" />
    <path d="M14 3v4a1 1 0 0 0 1 1h4" />
    <path d="M17 21h-10a2 2 0 0 1 -2 -2v-14a2 2 0 0 1 2 -2h7l5 5v11a2 2 0 0 1 -2 2z" />
  </svg>
{% endif %}


================================================
FILE: bookmarks/templates/bookmarks/details/assets.html
================================================
<div>
  {% if details.assets %}
    <div class="item-list assets">
      {% for asset in details.assets %}
        <div class="list-item" data-asset-id="{{ asset.id }}">
          <div class="list-item-icon {{ asset.icon_classes }}">{% include 'bookmarks/details/asset_icon.html' %}</div>
          <div class="list-item-text {{ asset.text_classes }}">
            <span class="truncate">
              {{ asset.display_name }}
              {% if asset.status == 'pending' %}(queued){% endif %}
              {% if asset.status == 'failure' %}(failed){% endif %}
            </span>
            {% if asset.file_size %}<span class="filesize">{{ asset.file_size|filesizeformat }}</span>{% endif %}
          </div>
          <div class="list-item-actions">
            {% if asset.file %}
              <a class="btn btn-link"
                 href="{% url 'linkding:assets.view' asset.id %}"
                 target="_blank">View</a>
            {% endif %}
            {% if details.is_editable %}
              <button data-confirm
                      type="submit"
                      name="remove_asset"
                      value="{{ asset.id }}"
                      class="btn btn-link">Remove</button>
            {% endif %}
          </div>
        </div>
      {% endfor %}
    </div>
  {% endif %}
  {% if details.is_editable %}
    <div class="assets-actions">
      {% if details.snapshots_enabled %}
        <button type="submit"
                name="create_html_snapshot"
                value="{{ details.bookmark.id }}"
                class="btn btn-sm"
                {% if details.has_pending_assets %}disabled{% endif %}>Create HTML snapshot</button>
      {% endif %}
      {% if details.uploads_enabled %}
        <ld-upload-button>
          <button id="upload-asset"
                  name="upload_asset"
                  value="{{ details.bookmark.id }}"
                  type="submit"
                  class="btn btn-sm">Upload file</button>
          <input id="upload-asset-file"
                 name="upload_asset_file"
                 type="file"
                 class="d-hide">
        </ld-upload-button>
      {% endif %}
    </div>
  {% endif %}
</div>


================================================
FILE: bookmarks/templates/bookmarks/details/form.html
================================================
{% load static %}
{% load shared %}
<ld-form>
  <form action="{{ details.action_url }}"
        method="post"
        enctype="multipart/form-data">
    {% csrf_token %}
    <input type="hidden" name="update_state" value="{{ details.bookmark.id }}">
    <div class="weblinks">
      <a class="weblink"
         href="{{ details.bookmark.url }}"
         rel="noopener"
         target="{{ details.profile.bookmark_link_target }}">
        {% if details.show_link_icons %}
          <img class="favicon"
               src="{% static details.bookmark.favicon_file %}"
               alt="">
        {% endif %}
        <span>{{ details.bookmark.url }}</span>
      </a>
      {% if details.latest_snapshot %}
        <a class="weblink"
           href="{% url 'linkding:assets.read' details.latest_snapshot.id %}"
           target="{{ details.profile.bookmark_link_target }}">
          {% if details.show_link_icons %}
            <svg class="favicon">
              <use href="{% static 'icons.svg' %}?v={{ app_version }}#unread"></use>
            </svg>
          {% endif %}
          <span>Reader mode</span>
        </a>
      {% endif %}
      {% if details.web_archive_snapshot_url %}
        <a class="weblink"
           href="{{ details.web_archive_snapshot_url }}"
           target="{{ details.profile.bookmark_link_target }}">
          {% if details.show_link_icons %}
            <svg class="favicon"
                 viewBox="0 0 76 86"
                 xmlns="http://www.w3.org/2000/svg">
              <path d="m76 82v4h-76l.00080851-4zm-3-6v5h-70v-5zm-62.6696277-54 .8344146.4217275.4176066 6.7436084.4176065 10.9576581v10.5383496l-.4176065 13.1364492-.0694681 8.8498268-1.1825531.3523804h-4.17367003l-1.25202116-.3523804-.48627608-8.8498268-.41840503-13.0662957v-10.5375432l.41840503-11.028618.38167482-6.7798947.87034634-.3854412zm60.0004653 0 .8353798.4217275.4168913 6.7436084.4168913 10.9576581v10.5383496l-.4168913 13.1364492-.0686832 8.8498268-1.1835879.3523804h-4.1737047l-1.2522712-.3523804-.4879704-8.8498268-.4168913-13.0662957v-10.5375432l.4168913-11.028618.3833483-6.7798947.8697215-.3854412zm-42.000632 0 .8344979.4217275.4176483 6.7436084.4176482 10.9576581v10.5383496l-.4176482 13.1364492-.0686764 8.8498268-1.1834698.3523804h-4.1740866l-1.2529447-.3523804-.4863246-8.8498268-.4168497-13.0662957v-10.5375432l.4168497-11.028618.38331-6.7798947.8688361-.3854412zm23 0 .8344979.4217275.4176483 6.7436084.4176482 10.9576581v10.5383496l-.4176482 13.1364492-.0686764 8.8498268-1.1834698.3523804h-4.1740866l-1.2521462-.3523804-.4871231-8.8498268-.4168497-13.0662957v-10.5375432l.4168497-11.028618.38331-6.7798947.8696347-.3854412zm21.6697944-9v7h-70v-7zm-35.7200748-13 36.7200748 8.4088317-1.4720205 2.5911683h-70.32799254l-2.19998696-2.10140371z" fill="currentColor" fill-rule="evenodd" />
            </svg>
          {% endif %}
          <span>Internet Archive</span>
        </a>
      {% endif %}
    </div>
    {% if details.preview_image_enabled and details.bookmark.preview_image_file %}
      <div class="preview-image">
        <img src="{% static details.bookmark.preview_image_file %}" alt="" />
      </div>
    {% endif %}
    <div class="sections grid columns-2 columns-sm-1 gap-0">
      {% if details.is_editable %}
        <section class="status col-2">
          <h3>Status</h3>
          <div class="d-flex" style="gap: .8rem">
            <div class="form-group">
              <label class="form-checkbox">
                <input data-submit-on-change
                       type="checkbox"
                       name="is_archived"
                       {% if details.bookmark.is_archived %}checked{% endif %}>
                <i class="form-icon"></i> Archived
              </label>
            </div>
            <div class="form-group">
              <label class="form-checkbox">
                <input data-submit-on-change
                       type="checkbox"
                       name="unread"
                       {% if details.bookmark.unread %}checked{% endif %}>
                <i class="form-icon"></i> Unread
              </label>
            </div>
            {% if details.profile.enable_sharing %}
              <div class="form-group">
                <label class="form-checkbox">
                  <input data-submit-on-change
                         type="checkbox"
                         name="shared"
                         {% if details.bookmark.shared %}checked{% endif %}>
                  <i class="form-icon"></i> Shared
                </label>
              </div>
            {% endif %}
          </div>
        </section>
      {% endif %}
      <section class="files col-2">
        <h3>Files</h3>
        <div>{% include 'bookmarks/details/assets.html' %}</div>
      </section>
      {% if details.bookmark.tag_names %}
        <section class="tags col-1">
          <h3 id="details-modal-tags-title">Tags</h3>
          <div>
            {% for tag in details.tags %}
              <a href="{% url 'linkding:bookmarks.index' %}?{{ tag.query_string }}">#{{ tag.name }}</a>
            {% endfor %}
          </div>
        </section>
      {% endif %}
      <section class="date-added col-1">
        <h3>Date added</h3>
        <div>
          <span>{{ details.bookmark.date_added }}</span>
        </div>
      </section>
      {% if details.bookmark.resolved_description %}
        <section class="description col-2">
          <h3>Description</h3>
          <div>{{ details.bookmark.resolved_description }}</div>
        </section>
      {% endif %}
      {% if details.bookmark.notes %}
        <section class="notes col-2">
          <h3>Notes</h3>
          <div class="markdown">{% markdown details.bookmark.notes %}</div>
        </section>
      {% endif %}
    </div>
  </form>
</ld-form>


================================================
FILE: bookmarks/templates/bookmarks/details/modal.html
================================================
<turbo-frame id="details-modal" target="_top">
{% if details %}
  <ld-details-modal class="modal active bookmark-details"
                    data-bookmark-id="{{ details.bookmark.id }}"
                    data-close-url="{{ details.close_url }}"
                    data-turbo-frame="details-modal">
    <div class="modal-overlay" data-close-modal></div>
    <div class="modal-container" role="dialog" aria-modal="true">
      {% include 'shared/modal_header.html' with title=details.bookmark.resolved_title %}
      <div class="modal-body">{% include 'bookmarks/details/form.html' %}</div>
      {% if details.is_editable %}
        <div class="modal-footer">
          <div class="actions">
            <div class="left-actions">
              <a class="btn btn-wide"
                 href="{% url 'linkding:bookmarks.edit' details.bookmark.id %}?return_url={{ details.edit_return_url|urlencode }}">Edit</a>
            </div>
            <div class="right-actions">
              <form action="{{ details.delete_url }}"
                    method="post"
                    data-turbo-action="replace">
                {% csrf_token %}
                <input type="hidden" name="disable_turbo" value="true">
                <button data-confirm
                        class="btn btn-error btn-wide"
                        type="submit"
                        name="remove"
                        value="{{ details.bookmark.id }}">Delete</button>
              </form>
            </div>
          </div>
        </div>
      {% endif %}
    </div>
  </ld-details-modal>
{% endif %}
</turbo-frame>


================================================
FILE: bookmarks/templates/bookmarks/edit.html
================================================
{% extends 'shared/layout.html' %}
{% block head %}
  {% with page_title="Edit bookmark - Linkding" %}{{ block.super }}{% endwith %}
{% endblock %}
{% block content %}
  <div class="bookmarks-form-page">
    <main aria-labelledby="main-heading">
      <div class="section-header">
        <h1 id="main-heading">Edit bookmark</h1>
      </div>
      <ld-form data-submit-on-ctrl-enter>
        <form action="{% url 'linkding:bookmarks.edit' bookmark_id %}?return_url={{ return_url|urlencode }}"
              method="post"
              novalidate>
          {% include 'bookmarks/form.html' %}
        </form>
      </ld-form>
    </main>
  </div>
{% endblock %}


================================================
FILE: bookmarks/templates/bookmarks/empty_bookmarks.html
================================================
<div class="empty mt-4">
  {% if not bookmark_list.query_is_valid %}
    <p class="empty-title h5">Invalid search query</p>
    <p class="empty-subtitle">
      The search query you entered is not valid. Common reasons are unclosed parentheses or a logical operator (AND, OR,
      NOT) without operands. The error message from the parser is: "{{ bookmark_list.query_error_message }}".
    </p>
  {% else %}
    <p class="empty-title h5">You have no bookmarks yet</p>
    <p class="empty-subtitle">
      You can get started by <a href="{% url 'linkding:bookmarks.new' %}">adding</a> bookmarks,
      <a href="{% url 'linkding:settings.general' %}">importing</a> your existing bookmarks or configuring the
      <a href="{% url 'linkding:settings.integrations' %}">browser extension</a> or the <a href="{% url 'linkding:settings.integrations' %}">bookmarklet</a>.
    </p>
  {% endif %}
</div>


================================================
FILE: bookmarks/templates/bookmarks/form.html
================================================
{% load static %}
{% load shared %}
<div class="bookmarks-form">
  {% csrf_token %}
  {{ form.auto_close }}
  <div class="form-group">
    {% formlabel form.url "URL" %}
    <div class="has-icon-right">
      {% formfield form.url autofocus=True %}
      <i class="form-icon loading"></i>
    </div>
    {{ form.url.errors }}
    <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">
    {% formlabel form.tag_string "Tags" %}
    {% formfield form.tag_string has_help=True %}
    {% formhelp form.tag_string %}
      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.
    {% endformhelp %}
    <div class="form-input-hint auto-tags"></div>
  </div>
  <div class="form-group">
    <div class="d-flex justify-between align-baseline">
      {% formlabel form.title "Title" %}
      <div class="flex">
        <button id="refresh-button" class="btn btn-link suffix-button" type="button">Refresh from website</button>
        <ld-clear-button data-for="{{ form.title.id_for_label }}">
          <button class="ml-2 btn btn-link suffix-button" type="button">Clear</button>
        </ld-clear-button>
      </div>
    </div>
    {% formfield form.title %}
  </div>
  <div class="form-group">
    <div class="d-flex justify-between align-baseline">
      {% formlabel form.description "Description" %}
      <ld-clear-button data-for="{{ form.description.id_for_label }}">
        <button class="btn btn-link suffix-button" type="button">Clear</button>
      </ld-clear-button>
    </div>
    {% formfield form.description rows="3" %}
  </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>
      {% formfield form.notes rows="8" has_help=True %}
      {% formhelp form.notes %}
        Additional notes, supports Markdown.
      {% endformhelp %}
    </details>
  </div>
  <div class="form-group">
    {% formfield form.unread label="Mark as unread" has_help=True %}
    {% formhelp form.unread %}
      Unread bookmarks can be filtered for, and marked as read after you had a chance to look at them.
    {% endformhelp %}
  </div>
  {% if request.user_profile.enable_sharing %}
    <div class="form-group">
      {% formfield form.shared label="Share" has_help=True %}
      {% formhelp form.shared %}
        {% if request.user_profile.enable_public_sharing %}
          Share this bookmark with other registered users and anonymous users.
        {% else %}
          Share this bookmark with other registered users.
        {% endif %}
      {% endformhelp %}
    </div>
  {% endif %}
  <div class="divider"></div>
  <div class="form-group d-flex justify-between">
    {% if form.is_auto_close %}
      <input type="submit" value="Save and close" class="btn btn-primary btn-wide">
    {% else %}
      <input type="submit"
             value="Save"
             class="btn btn-primary btn btn-primary btn-wide">
    {% endif %}
    <a href="{{ return_url }}" class="btn">Cancel</a>
  </div>
  <script type="application/javascript">
    /**
     * - Pre-fill title and description with metadata from website as soon as URL changes
     * - Show hint if URL is already bookmarked
     */
    (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 unreadCheckbox = document.getElementById('{{ form.unread.id_for_label }}');
      const sharedCheckbox = document.getElementById('{{ form.shared.id_for_label }}');
      const refreshButton = document.getElementById('refresh-button');
      const bookmarkExistsHint = document.querySelector('.form-input-hint.bookmark-exists');
      const editedBookmarkId = parseInt('{{ form.instance.id|default:0 }}');
      let isTitleModified = !!titleInput.value;
      let isDescriptionModified = !!descriptionInput.value;

      function toggleLoadingIcon(input, show) {
        const icon = input.parentNode.querySelector('i.form-icon');
        icon.style['visibility'] = show ? 'visible' : 'hidden';
      }

      function updateInput(input, value) {
        if (!input) {
          return;
        }
        input.value = value;
        input.dispatchEvent(new Event('value-changed'));
      }

      function updateCheckbox(input, value) {
        if (!input) {
          return;
        }
        input.checked = value;
      }

      function checkUrl() {
        if (!urlInput.value) {
          return;
        }

        toggleLoadingIcon(urlInput, true);

        const websiteUrl = encodeURIComponent(urlInput.value);
        const requestUrl = `{% url 'linkding:api-root' %}bookmarks/check?url=${websiteUrl}`;
        fetch(requestUrl)
          .then(response => response.json())
          .then(data => {
            const metadata = data.metadata;
            toggleLoadingIcon(urlInput, false);

            // Display hint if URL is already bookmarked
            const existingBookmark = data.bookmark;
            bookmarkExistsHint.style['display'] = existingBookmark ? 'block' : 'none';
            refreshButton.style['display'] = existingBookmark ? 'inline-block' : 'none';

            // Prefill form with existing bookmark data
            if (existingBookmark) {
              // Workaround: tag input will be replaced by tag autocomplete, so
              // defer getting the input until we need it
              const tagsInput = document.getElementById('{{ form.tag_string.id_for_label }}');

              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 {
              // Update title and description with website metadata, unless they have been modified
              if (!isTitleModified) {
                updateInput(titleInput, metadata.title);
              }
              if (!isDescriptionModified) {
                updateInput(descriptionInput, metadata.description);
              }
            }

            // Preview auto tags
            const autoTags = data.auto_tags;
            const autoTagsHint = document.querySelector('.form-input-hint.auto-tags');

            if (autoTags.length > 0) {
              autoTags.sort();
              autoTagsHint.style['display'] = 'block';
              autoTagsHint.innerHTML = `Auto tags: ${autoTags.join(" ")}`;
            } else {
              autoTagsHint.style['display'] = 'none';
            }
          });
      }

      function refreshMetadata() {
        if (!urlInput.value) {
          return;
        }

        toggleLoadingIcon(urlInput, true);

        const websiteUrl = encodeURIComponent(urlInput.value);
        const requestUrl = `{% url 'linkding:api-root' %}bookmarks/check?url=${websiteUrl}&ignore_cache=true`;

        fetch(requestUrl)
          .then(response => response.json())
          .then(data => {
            const metadata = data.metadata;
            const existingBookmark = data.bookmark;
            toggleLoadingIcon(urlInput, false);

            if (metadata.title && metadata.title !== existingBookmark?.title) {
              titleInput.value = metadata.title;
              titleInput.classList.add("modified");
            }

            if (metadata.description && metadata.description !== existingBookmark?.description) {
              descriptionInput.value = metadata.description;
              descriptionInput.classList.add("modified");
            }
          });
      }

      refreshButton.addEventListener('click', refreshMetadata);

      // Fetch website metadata when page loads and when URL changes, unless we are editing an existing bookmark
      if (!editedBookmarkId) {
        checkUrl();
        urlInput.addEventListener('input', checkUrl);
        titleInput.addEventListener('input', () => {
          isTitleModified = true;
        });
        descriptionInput.addEventListener('input', () => {
          isDescriptionModified = true;
        });
      } else {
        refreshButton.style['display'] = 'inline-block';
      }
    })();
  </script>
</div>


================================================
FILE: bookmarks/templates/bookmarks/new.html
================================================
{% extends 'shared/layout.html' %}
{% block head %}
  {% with page_title="New bookmark - Linkding" %}{{ block.super }}{% endwith %}
{% endblock %}
{% block content %}
  <div class="bookmarks-form-page">
    <main aria-labelledby="main-heading">
      <div class="section-header">
        <h1 id="main-heading">New bookmark</h1>
      </div>
      <ld-form data-submit-on-ctrl-enter>
        <form action="{% url 'linkding:bookmarks.new' %}" method="post" novalidate>
          {% include 'bookmarks/form.html' %}
        </form>
      </ld-form>
    </main>
  </div>
{% endblock %}


================================================
FILE: bookmarks/templates/bookmarks/read.html
================================================
{% load static %}
<!DOCTYPE html>
<html lang="en" class="reader-mode">
  <head>
    <meta charset="UTF-8">
    <title>Reader view</title>
    <meta name="viewport"
          content="width=device-width, initial-scale=1.0, minimal-ui">
    {# Include specific theme variant based on user profile setting #}
    {% if request.user_profile.theme == 'light' %}
      <link href="{% static 'theme-light.css' %}?v={{ app_version }}"
            rel="stylesheet"
            type="text/css" />
      <meta name="theme-color" content="#5856e0">
    {% elif request.user_profile.theme == 'dark' %}
      <link href="{% static 'theme-dark.css' %}?v={{ app_version }}"
            rel="stylesheet"
            type="text/css" />
      <meta name="theme-color" content="#161822">
    {% else %}
      {# Use auto theme as fallback #}
      <link href="{% static 'theme-dark.css' %}?v={{ app_version }}"
            rel="stylesheet"
            type="text/css"
            media="(prefers-color-scheme: dark)" />
      <link href="{% static 'theme-light.css' %}?v={{ app_version }}"
            rel="stylesheet"
            type="text/css"
            media="(prefers-color-scheme: light)" />
      <meta name="theme-color"
            media="(prefers-color-scheme: dark)"
            content="#161822">
      <meta name="theme-color"
            media="(prefers-color-scheme: light)"
            content="#5856e0">
    {% endif %}
    {% if request.user_profile.custom_css %}
      <link href="{% url 'linkding:custom_css' %}?hash={{ request.user_profile.custom_css_hash }}"
            rel="stylesheet"
            type="text/css" />
    {% endif %}
  </head>
  <body>
    <template id="content">{{ content|safe }}</template>
    <script src="{% static 'vendor/Readability.js' %}"
            type="application/javascript"></script>
    <script type="application/javascript">
      function estimateReadingTime(charCount, wordsPerMinute) {
        const avgWordLength = 5;
        const totalWords = charCount / avgWordLength;
        return Math.ceil(totalWords / wordsPerMinute);
      }

      function postProcess(articleContent) {
        articleContent.querySelectorAll('table').forEach(table => {
          table.classList.add('table');
        });
      }

      function makeReadable() {
        const content = document.getElementById('content');
        const contentHtml = content.innerHTML;
        const dom = new DOMParser().parseFromString(contentHtml, 'text/html');
        const article = new Readability(dom).parse();

        document.title = article.title;

        const container = document.createElement('div');
        container.classList.add('container');

        const articleTitle = document.createElement('h1');
        articleTitle.textContent = article.title;
        container.append(articleTitle);

        const byline = [article.byline, article.siteName].filter(Boolean);
        if (byline.length > 0) {
          const articleByline = document.createElement('p');
          articleByline.textContent = byline.join(' | ');
          articleByline.classList.add('byline');
          container.append(articleByline);
        }

        if (article.length) {
          const minTime = estimateReadingTime(article.length, 225);
          const maxTime = estimateReadingTime(article.length, 175);

          const articleReadingTime = document.createElement('p');
          articleReadingTime.textContent = `${minTime}-${maxTime} minutes`;
          articleReadingTime.classList.add('reading-time');
          container.append(articleReadingTime);
        }

        const divider = document.createElement('hr');
        container.append(divider);

        const articleContent = document.createElement('div');
        articleContent.innerHTML = article.content;
        postProcess(articleContent);
        container.append(articleContent);

        content.replaceWith(container);
      }
      makeReadable();
    </script>
  </body>
</html>


================================================
FILE: bookmarks/templates/bookmarks/search.html
================================================
{% load static shared %}
<div class="search-container">
  <form id="search" action="" method="get" role="search">
    <ld-search-autocomplete input-name="q"
                            input-placeholder="Search for words or #tags"
                            input-value="{{ search.q|default_if_none:'' }}"
                            target="{{ request.user_profile.bookmark_link_target }}"
                            mode="{{ mode }}"
                            user="{{ search.user }}"
                            shared="{{ search.shared }}"
                            unread="{{ search.unread }}">
    </ld-search-autocomplete>
    <input type="submit" value="Search" class="d-none">
    {% for hidden_field in search_form.hidden_fields %}{{ hidden_field }}{% endfor %}
  </form>
  <ld-dropdown class="search-options dropdown dropdown-right">
    <button type="button"
            aria-label="Search preferences"
            class="btn dropdown-toggle{% if search.has_modified_preferences %} badge{% endif %}">
      <svg width="20" height="20">
        <use href="{% static 'icons.svg' %}?v={{ app_version }}#preferences"></use>
      </svg>
    </button>
    <div class="menu" tabindex="0">
      <form id="search_preferences" action="" method="post">
        {% csrf_token %}
        {% if 'sort' in preferences_form.editable_fields %}
          <div class="form-group">
            <label for="{{ preferences_form.sort.id_for_label }}"
                   class="form-label{% if 'sort' in search.modified_params %} text-bold{% endif %}">Sort by</label>
            {% formfield preferences_form.sort class='select-sm' %}
          </div>
        {% endif %}
        {% if 'shared' in preferences_form.editable_fields %}
          <div class="form-group radio-group"
               role="radiogroup"
               aria-labelledby="search-shared-label">
            <label id="search-shared-label"
                   class="form-label{% if 'shared' in search.modified_params %} text-bold{% endif %}">
              Shared filter
            </label>
            {% for radio in preferences_form.shared %}
              <label for="{{ radio.id_for_label }}" class="form-radio form-inline">
                {{ radio.tag }}
                <i class="form-icon"></i>
                {{ radio.choice_label }}
              </label>
            {% endfor %}
          </div>
        {% endif %}
        {% if 'unread' in preferences_form.editable_fields %}
          <div class="form-group radio-group"
               role="radiogroup"
               aria-labelledby="search-unread-label">
            <label id="search-unread-label"
                   class="form-label{% if 'unread' in search.modified_params %} text-bold{% endif %}">
              Unread filter
            </label>
            {% for radio in preferences_form.unread %}
              <label for="{{ radio.id_for_label }}" class="form-radio form-inline">
                {{ radio.tag }}
                <i class="form-icon"></i>
                {{ radio.choice_label }}
              </label>
            {% endfor %}
          </div>
        {% endif %}
        <div class="actions">
          <button type="submit" class="btn btn-sm btn-primary" name="apply">Apply</button>
          {% if request.user.is_authenticated %}
            <button type="submit" class="btn btn-sm" name="save">Save as default</button>
          {% endif %}
        </div>
        {% for hidden_field in preferences_form.hidden_fields %}{{ hidden_field }}{% endfor %}
      </form>
    </div>
  </ld-dropdown>
</div>


================================================
FILE: bookmarks/templates/bookmarks/tag_cloud.html
================================================
{% load shared %}
{% htmlmin %}
<div class="tag-cloud">
  {% if tag_cloud.has_selected_tags %}
    <p class="selected-tags">
      {% for tag in tag_cloud.selected_tags %}
        <a href="?{{ tag.query_string }}" class="text-bold mr-2">
          <span>-{{ tag.name }}</span>
        </a>
      {% endfor %}
    </p>
  {% endif %}
  <div class="unselected-tags">
    {% for group in tag_cloud.groups %}
      <p class="group">
        {% for tag in group.tags %}
          {# Highlight first char of first tag in group if grouping is enabled #}
          {% if group.highlight_first_char and forloop.counter == 1 %}
            <a href="?{{ tag.query_string }}" 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 tags normally #}
            <a href="?{{ tag.query_string }}" class="mr-2" data-is-tag-item>
              <span>{{ tag.name }}</span>
            </a>
          {% endif %}
        {% endfor %}
      </p>
    {% endfor %}
  </div>
</div>
{% endhtmlmin %}


================================================
FILE: bookmarks/templates/bookmarks/tag_section.html
================================================
{% load static %}
<section aria-labelledby="tags-heading">
  <div class="section-header no-wrap">
    <h2 id="tags-heading">Tags</h2>
    {% if user.is_authenticated %}
      <ld-dropdown class="dropdown dropdown-right ml-auto">
        <button class="btn btn-noborder dropdown-toggle" aria-label="Tags menu">
          <svg width="20" height="20">
            <use href="{% static 'icons.svg' %}?v={{ app_version }}#menu"></use>
          </svg>
        </button>
        <ul class="menu" role="list" tabindex="-1">
          <li class="menu-item">
            <a href="{% url 'linkding:tags.index' %}" class="menu-link">Manage tags</a>
          </li>
        </ul>
      </ld-dropdown>
    {% endif %}
  </div>
  <div id="tag-cloud-container">{% include 'bookmarks/tag_cloud.html' %}</div>
</section>


================================================
FILE: bookmarks/templates/bookmarks/user_section.html
================================================
{% load shared %}
<section aria-labelledby="user-heading">
  <div class="section-header">
    <h2 id="user-heading">User</h2>
  </div>
  <div>
    <ld-form data-form-reset>
      <form id="user-select" action="" method="get">
        {% for hidden_field in user_list.form.hidden_fields %}{{ hidden_field }}{% endfor %}
        <div class="form-group">
          <div class="d-flex">
            {% formfield user_list.form.user data_submit_on_change="" %}
            <noscript>
              <button type="submit" class="btn btn-link ml-2">Apply</button>
            </noscript>
          </div>
        </div>
      </form>
    </ld-form>
    <br>
  </div>
</section>


================================================
FILE: bookmarks/templates/bundles/edit.html
================================================
{% extends 'shared/layout.html' %}
{% block head %}
  {% with page_title="Edit bundle - Linkding" %}{{ block.super }}{% endwith %}
{% endblock %}
{% block content %}
  <div class="bundles-editor-page grid columns-md-1">
    <main aria-labelledby="main-heading">
      <div class="section-header">
        <h1 id="main-heading">Edit bundle</h1>
      </div>
      {% include 'shared/messages.html' %}
      <form id="bundle-form"
            action="{% url 'linkding:bundles.edit' bundle.id %}"
            method="post"
            novalidate>
        {% csrf_token %}
        {% include 'bundles/form.html' %}
      </form>
    </main>
    <aside class="col-2" aria-labelledby="preview-heading">
      <div class="section-header">
        <h2 id="preview-heading">Preview</h2>
      </div>
      {% include 'bundles/preview.html' %}
    </aside>
  </div>
{% endblock %}


================================================
FILE: bookmarks/templates/bundles/form.html
================================================
{% load shared %}
<div class="form-group">
  {% formlabel form.name "Name" %}
  {% formfield form.name %}
  {{ form.name.errors }}
</div>
<div class="form-group">
  {% formlabel form.search "Search terms" %}
  {% formfield form.search has_help=True %}
  {{ form.search.errors }}
  {% formhelp form.search %}
    All of these search terms must be present in a bookmark to match.
  {% endformhelp %}
</div>
<div class="form-group">
  {% formlabel form.any_tags "Tags" %}
  {% formfield form.any_tags has_help=True %}
  {% formhelp form.any_tags %}
    At least one of these tags must be present in a bookmark to match.
  {% endformhelp %}
</div>
<div class="form-group">
  {% formlabel form.all_tags "Required tags" %}
  {% formfield form.all_tags has_help=True %}
  {% formhelp form.all_tags %}
    All of these tags must be present in a bookmark to match.
  {% endformhelp %}
</div>
<div class="form-group">
  {% formlabel form.excluded_tags "Excluded tags" %}
  {% formfield form.excluded_tags has_help=True %}
  {% formhelp form.excluded_tags %}
    None of these tags must be present in a bookmark to match.
  {% endformhelp %}
</div>
<div class="form-group">
  {% formlabel form.filter_unread "Reading State" %}
  {% formfield form.filter_unread has_help=True %}
  {% formhelp form.filter_unread %}
    Limit matches to unread or read bookmarks.
  {% endformhelp %}
</div>
<div class="form-group">
  {% formlabel form.filter_shared "Sharing State" %}
  {% formfield form.filter_shared has_help=True %}
  {% formhelp form.filter_shared %}
    Limit matches to shared or unshared bookmarks.
  {% endformhelp %}
</div>
<div class="form-footer d-flex mt-4">
  <input type="submit"
         name="save"
         value="Save"
         class="btn btn-primary btn-wide">
  <a href="{% url 'linkding:bundles.index' %}"
     class="btn btn-wide ml-auto">Cancel</a>
  <a href="{% url 'linkding:bundles.preview' %}"
     data-turbo-frame="preview"
     class="d-none"
     id="preview-link"></a>
</div>
<script>
  (function init() {
    const bundleForm = document.getElementById('bundle-form');
    const previewLink = document.getElementById('preview-link');

    let pendingUpdate;

    function scheduleUpdate() {
      if (pendingUpdate) {
        clearTimeout(pendingUpdate);
      }
      pendingUpdate = setTimeout(() => {
        // Ignore if link has been removed (e.g. form submit or navigation)
        if (!previewLink.isConnected) {
          return;
        }

        const baseUrl = previewLink.href.split('?')[0];
        const params = new URLSearchParams();
        const inputs = bundleForm.querySelectorAll('input[type="text"]:not([name="csrfmiddlewaretoken"]), textarea, select');

        inputs.forEach(input => {
          if (input.name && input.value.trim()) {
            params.set(input.name, input.value.trim());
          }
        });

        previewLink.href = params.toString() ? `${baseUrl}?${params.toString()}` : baseUrl;
        previewLink.click();
      }, 500)
    }

    bundleForm.addEventListener('input', scheduleUpdate);
  })();
</script>


================================================
FILE: bookmarks/templates/bundles/index.html
================================================
{% extends "shared/layout.html" %}
{% load static %}
{% block head %}
  {% with page_title="Bundles - Linkding" %}{{ block.super }}{% endwith %}
{% endblock %}
{% block content %}
  <main class="bundles-page crud-page" aria-labelledby="main-heading">
    <div class="crud-header">
      <h1 id="main-heading">Bundles</h1>
      <a href="{% url 'linkding:bundles.new' %}" class="btn">Add bundle</a>
    </div>
    {% include 'shared/messages.html' %}
    {% if bundles %}
      <form action="{% url 'linkding:bundles.action' %}" method="post">
        {% csrf_token %}
        <table class="table crud-table">
          <thead>
            <tr>
              <th>Name</th>
              <th class="actions">
                <span class="text-assistive">Actions</span>
              </th>
            </tr>
          </thead>
          <tbody>
            {% for bundle in bundles %}
              <tr data-bundle-id="{{ bundle.id }}" draggable="true">
                <td>
                  <div class="d-flex align-center">
                    <svg class="text-secondary mr-1" width="16" height="16">
                      <use href="{% static 'icons.svg' %}?v={{ app_version }}#drag"></use>
                    </svg>
                    <span>{{ bundle.name }}</span>
                  </div>
                </td>
                <td class="actions">
                  <a class="btn btn-link"
                     href="{% url 'linkding:bundles.edit' bundle.id %}">Edit</a>
                  <button data-confirm
                          type="submit"
                          name="remove_bundle"
                          value="{{ bundle.id }}"
                          class="btn btn-link">Remove</button>
                </td>
              </tr>
            {% endfor %}
          </tbody>
        </table>
        <input type="submit" name="move_bundle" value="" class="d-none">
        <input type="hidden" name="move_position" value="">
      </form>
    {% else %}
      <div class="empty">
        <p class="empty-title h5">You have no bundles yet</p>
        <p class="empty-subtitle">Create your first bundle to get started</p>
      </div>
    {% endif %}
  </main>
  <script>
    (function init() {
      const tableBody = document.querySelector(".crud-table tbody");
      if (!tableBody) return;

      let draggedElement = null;

      const rows = tableBody.querySelectorAll('tr');
      rows.forEach((item) => {
        item.addEventListener('dragstart', handleDragStart);
        item.addEventListener('dragend', handleDragEnd);
        item.addEventListener('dragover', handleDragOver);
        item.addEventListener('dragenter', handleDragEnter);
      });

      function handleDragStart(e) {
        draggedElement = this;

        e.dataTransfer.effectAllowed = 'move';
        e.dataTransfer.dropEffect = 'move';

        this.classList.add('drag-start');
        setTimeout(() => {
          this.classList.remove('drag-start');
          this.classList.add('dragging');
        }, 0);
      }

      function handleDragEnd() {
        this.classList.remove('dragging');

        const moveBundleInput = document.querySelector('input[name="move_bundle"]');
        const movePositionInput = document.querySelector('input[name="move_position"]');
        moveBundleInput.value = draggedElement.getAttribute('data-bundle-id');
        movePositionInput.value = Array.from(tableBody.children).indexOf(draggedElement);

        const form = this.closest('form');
        form.requestSubmit(moveBundleInput);

        draggedElement = null;
      }

      function handleDragOver(e) {
        if (e.preventDefault) {
          e.preventDefault();
        }
        return false;
      }

      function handleDragEnter() {
        if (this !== draggedElement) {
          const listItems = Array.from(tableBody.children);
          const draggedIndex = listItems.indexOf(draggedElement);
          const currentIndex = listItems.indexOf(this);

          if (draggedIndex < currentIndex) {
            this.insertAdjacentElement('afterend', draggedElement);
          } else {
            this.insertAdjacentElement('beforebegin', draggedElement);
          }
        }
      }
    })();
  </script>
{% endblock %}


================================================
FILE: bookmarks/templates/bundles/new.html
================================================
{% extends 'shared/layout.html' %}
{% block head %}
  {% with page_title="New bundle - Linkding" %}{{ block.super }}{% endwith %}
{% endblock %}
{% block content %}
  <div class="bundles-editor-page grid columns-md-1">
    <main aria-labelledby="main-heading">
      <div class="section-header">
        <h1 id="main-heading">New bundle</h1>
      </div>
      {% include 'shared/messages.html' %}
      <form id="bundle-form"
            action="{% url 'linkding:bundles.new' %}"
            method="post"
            novalidate>
        {% csrf_token %}
        {% include 'bundles/form.html' %}
      </form>
    </main>
    <aside class="col-2" aria-labelledby="preview-heading">
      <div class="section-header">
        <h2 id="preview-heading">Preview</h2>
      </div>
      {% include 'bundles/preview.html' %}
    </aside>
  </div>
{% endblock %}


================================================
FILE: bookmarks/templates/bundles/preview.html
================================================
<turbo-frame id="preview">
{% if bookmark_list.is_empty %}
  <div>No bookmarks match the current bundle.</div>
{% else %}
  <div class="mb-4">Found {{ bookmark_list.bookmarks_total }} bookmarks matching this bundle.</div>
  {% with pagination_frame="preview" %}
    {% include 'bookmarks/bookmark_list.html' %}
  {% endwith %}
{% endif %}
</turbo-frame>


================================================
FILE: bookmarks/templates/opensearch.xml
================================================
<OpenSearchDescription xmlns="http://a9.com/-/spec/opensearch/1.1/" xmlns:moz="http://www.mozilla.org/2006/browser/search/">
    <ShortName>Linkding</ShortName>
    <Description>Linkding</Description>
    <InputEncoding>UTF-8</InputEncoding>
    <Image width="16" height="16" type="image/x-icon">{{base_url}}static/favicon.ico</Image>
    <Url type="text/html" template="{{ bookmarks_url }}?client=opensearch&amp;q={searchTerms}"/>
</OpenSearchDescription>


================================================
FILE: bookmarks/templates/registration/login.html
================================================
{% extends 'shared/layout.html' %}
{% load shared %}
{% block head %}
  {% with page_title="Login - Linkding" %}{{ block.super }}{% endwith %}
{% endblock %}
{% block content %}
  <main class="auth-page" aria-labelledby="main-heading">
    <div class="section-header">
      <h1 id="main-heading">Login</h1>
    </div>
    {% if not disable_login %}
      <form method="post" action="{% url 'login' %}">
        {% csrf_token %}
        {% if form.errors %}
          <p class="form-input-hint is-error">Your username and password didn't match. Please try again.</p>
        {% endif %}
        <div class="form-group">
          {% formlabel form.username 'Username' %}
          {% formfield form.username class='form-input' %}
        </div>
        <div class="form-group">
          {% formlabel form.password 'Password' %}
          {% formfield form.password class='form-input' %}
        </div>
        <input type="submit" value="Login" class="btn btn-primary width-100 mt-4" />
        <input type="hidden" name="next" value="{{ next }}" />
      </form>
    {% endif %}
    {% if enable_oidc %}
      <a class="btn width-100 mt-4"
         href="{% url 'oidc_authentication_init' %}"
         data-turbo="false">Login with OIDC</a>
    {% endif %}
  </main>
{% endblock %}


================================================
FILE: bookmarks/templates/registration/password_change_done.html
================================================
{% extends 'shared/layout.html' %}
{% block head %}
  {% with page_title="Password changed - Linkding" %}{{ block.super }}{% endwith %}
{% endblock %}
{% block content %}
  <main class="auth-page" aria-labelledby="main-heading">
    <div class="section-header">
      <h1 id="main-heading">Password Changed</h1>
    </div>
    <p class="text-success">Your password was changed successfully.</p>
  </main>
{% endblock %}


================================================
FILE: bookmarks/templates/registration/password_change_form.html
================================================
{% extends 'shared/layout.html' %}
{% load shared %}
{% block head %}
  {% with page_title="Change password - Linkding" %}{{ block.super }}{% endwith %}
{% endblock %}
{% block content %}
  <main class="auth-page" aria-labelledby="main-heading">
    <div class="section-header">
      <h1 id="main-heading">Change Password</h1>
    </div>
    <form method="post" action="{% url 'change_password' %}">
      {% csrf_token %}
      <div class="form-group">
        {% formlabel form.old_password 'Old password' %}
        {% formfield form.old_password class='form-input' %}
        {{ form.old_password.errors }}
      </div>
      <div class="form-group">
        {% formlabel form.new_password1 'New password' %}
        {% formfield form.new_password1 class='form-input' %}
        {{ form.new_password1.errors }}
      </div>
      <div class="form-group">
        {% formlabel form.new_password2 'Confirm new password' %}
        {% formfield form.new_password2 class='form-input' %}
        {{ form.new_password2.errors }}
      </div>
      <input type="submit"
             value="Change Password"
             class="btn btn-primary width-100 mt-4">
    </form>
  </main>
{% endblock %}


================================================
FILE: bookmarks/templates/settings/bookmarklet.js
================================================
(function () {
  const bookmarkUrl = window.location;

  let applicationUrl = '{{ application_url }}';
  applicationUrl += '?url=' + encodeURIComponent(bookmarkUrl);
  applicationUrl += '&auto_close';

  window.open(applicationUrl);
})();


================================================
FILE: bookmarks/templates/settings/bookmarklet_clientside.js
================================================
(function () {
  const bookmarkUrl = window.location;
  const title =
    document.querySelector('title')?.textContent ||
    document
      .querySelector(`meta[property='og:title']`)
      ?.getAttribute('content') ||
    '';
  const description =
    document
      .querySelector(`meta[name='description']`)
      ?.getAttribute('content') ||
    document
      .querySelector(`meta[property='og:description']`)
      ?.getAttribute(`content`) ||
    '';

  let applicationUrl = '{{ application_url }}';
  applicationUrl += '?url=' + encodeURIComponent(bookmarkUrl);
  applicationUrl += '&title=' + encodeURIComponent(title);
  applicationUrl += '&description=' + encodeURIComponent(description);
  applicationUrl += '&auto_close';

  window.open(applicationUrl);
})();


================================================
FILE: bookmarks/templates/settings/create_api_token_modal.html
================================================
<turbo-frame id="api-modal">
<form method="post"
      action="{% url 'linkding:settings.integrations.create_api_token' %}"
      data-turbo-frame="api-section">
  {% csrf_token %}
  <ld-modal class="modal active"
            data-close-url="{% url 'linkding:settings.integrations' %}"
            data-turbo-frame="api-modal">
    <div class="modal-overlay" data-close-modal></div>
    <div class="modal-container" role="dialog" aria-modal="true">
      {% include 'shared/modal_header.html' with title="Create API Token" %}
      <div class="modal-body">
        <div class="form-group">
          <label class="form-label" for="token-name">Token name</label>
          <input type="text"
                 class="form-input"
                 id="token-name"
                 name="name"
                 placeholder="e.g., Browser Extension, Mobile App"
                 value="API Token"
                 maxlength="128">
          <p class="form-input-hint">A descriptive name to identify the purpose of the token</p>
        </div>
      </div>
      <div class="modal-footer d-flex justify-between">
        <button type="button" class="btn btn-wide" data-close-modal>Cancel</button>
        <button type="submit" class="btn btn-primary">Create Token</button>
      </div>
    </div>
  </ld-modal>
</form>
</turbo-frame>


================================================
FILE: bookmarks/templates/settings/general.html
================================================
{% extends "shared/layout.html" %}
{% load shared %}
{% block head %}
  {% with page_title="Settings - Linkding" %}{{ block.super }}{% endwith %}
{% endblock %}
{% block content %}
  <main class="settings-page" aria-labelledby="main-heading">
    <h1 id="main-heading">Settings</h1>
    {# Profile section #}
    {% if success_message %}<div class="toast toast-success mb-4">{{ success_message }}</div>{% endif %}
    {% if error_message %}<div class="toast toast-error mb-4">{{ error_message }}</div>{% endif %}
    <section aria-labelledby="profile-heading">
      <h2 id="profile-heading">Profile</h2>
      <p>
        <a href="{% url 'change_password' %}">Change password</a>
      </p>
      <form action="{% url 'linkding:settings.update' %}"
            method="post"
            novalidate
            data-turbo="false">
        {% csrf_token %}
        <div class="form-group">
          {% formlabel form.theme "Theme" %}
          {% formfield form.theme has_help=True class="width-25 width-sm-100" %}
          {% formhelp form.theme %}
            Whether to use a light or dark theme, or automatically adjust the theme based on your system's settings.
          {% endformhelp %}
        </div>
        <div class="form-group">
          {% formlabel form.bookmark_date_display "Bookmark date format" %}
          {% formfield form.bookmark_date_display has_help=True class="width-25 width-sm-100" %}
          {% formhelp form.bookmark_date_display %}
            Whether to show bookmark dates as relative (how long ago), or as absolute dates. Alternatively the date can
            be hidden.
          {% endformhelp %}
        </div>
        <div class="form-group">
          {% formlabel form.bookmark_description_display "Bookmark description" %}
          {% formfield form.bookmark_description_display has_help=True class="width-25 width-sm-100" %}
          {% formhelp form.bookmark_description_display %}
            Whether to show bookmark descriptions and tags in the same line, or as separate blocks.
          {% endformhelp %}
        </div>
        <div class="form-group {% if request.user_profile.bookmark_description_display == 'inline' %}d-hide{% endif %}">
          {% formlabel form.bookmark_description_max_lines "Bookmark description max lines" %}
          {% formfield form.bookmark_description_max_lines has_help=True class="width-25 width-sm-100" %}
          {% formhelp form.bookmark_description_max_lines %}
            Limits the number of lines that are displayed for the bookmark description.
          {% endformhelp %}
        </div>
        <div class="form-group">
          {% formfield form.display_url label="Show bookmark URL" has_help=True %}
          {% formhelp form.display_url %}
            When enabled, this setting displays the bookmark URL below the title.
          {% endformhelp %}
        </div>
        <div class="form-group">
          {% formfield form.permanent_notes label="Show notes permanently" has_help=True %}
          {% formhelp form.permanent_notes %}
            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.
          {% endformhelp %}
        </div>
        <div class="form-group">
          <span class="form-label">Bookmark actions</span>
          {% formfield form.display_view_bookmark_action label="View" %}
          {% formfield form.display_edit_bookmark_action label="Edit" %}
          {% formfield form.display_archive_bookmark_action label="Archive" %}
          {% formfield form.display_remove_bookmark_action label="Remove" %}
          <div class="form-input-hint">Which actions to display for each bookmark.</div>
        </div>
        <div class="form-group">
          {% formlabel form.bookmark_link_target "Open bookmarks in" %}
          {% formfield form.bookmark_link_target has_help=True class="width-25 width-sm-100" %}
          {% formhelp form.bookmark_link_target %}
            Whether to open bookmarks a new page or in the same page.
          {% endformhelp %}
        </div>
        <div class="form-group">
          {% formlabel form.items_per_page "Items per page" %}
          {% formfield form.items_per_page has_help=True class="width-25 width-sm-100" min="10" %}
          {{ form.items_per_page.errors }}
          {% formhelp form.items_per_page %}
            The number of bookmarks to display per page.
          {% endformhelp %}
        </div>
        <div class="form-group">
          {% formfield form.sticky_pagination label="Sticky pagination" has_help=True %}
          {% formhelp form.sticky_pagination %}
            When enabled, the pagination controls will stick to the bottom of the screen, so that they are always
            visible without having to scroll to the end of the page first.
          {% endformhelp %}
        </div>
        <div class="form-group">
          {% formfield form.collapse_side_panel label="Collapse side panel" has_help=True %}
          {% formhelp form.collapse_side_panel %}
            When enabled, the tags side panel will be collapsed by default to give more space to the bookmark list.
            Instead, the tags are shown in an expandable drawer.
          {% endformhelp %}
        </div>
        <div class="form-group">
          {% formfield form.hide_bundles label="Hide bundles" has_help=True %}
          {% formhelp form.hide_bundles %}
            Allows to hide the bundles in the side panel if you don't intend to use them.
          {% endformhelp %}
        </div>
        <div class="form-group">
          {% formlabel form.tag_search "Tag search" %}
          {% formfield form.tag_search has_help=True class="width-25 width-sm-100" %}
          {% formhelp form.tag_search %}
            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.
          {% endformhelp %}
        </div>
        <div class="form-group">
          {% formfield form.legacy_search label="Enable legacy search" has_help=True %}
          {% formhelp form.legacy_search %}
            Since version 1.44.0, linkding has a new search engine that supports logical expressions (and, or, not).
            If you run into any issues with the new search, you can enable this option to temporarily switch back to the old search.
            Please report any issues you encounter with the new search on <a href="https://github.com/sissbruecker/linkding/issues"
    target="_blank">GitHub</a> so they can be addressed.
            This option will be removed in a future version.
          {% endformhelp %}
        </div>
        <div class="form-group">
          {% formlabel form.tag_grouping "Tag grouping" %}
          {% formfield form.tag_grouping has_help=True class="width-25 width-sm-100" %}
          {% formhelp form.tag_grouping %}
            In alphabetical mode, tags will be grouped by the first letter.
            If disabled, tags will not be grouped.
          {% endformhelp %}
        </div>
        <div class="form-group">
          <details {% if form.auto_tagging_rules.value %}open{% endif %}>
            <summary>
              <span class="form-label d-inline-block">Auto Tagging</span>
            </summary>
            <label for="{{ form.auto_tagging_rules.id_for_label }}"
                   class="text-assistive">Auto Tagging</label>
            <div>{% formfield form.auto_tagging_rules has_help=True class="monospace" rows="6" %}</div>
          </details>
          {% formhelp form.auto_tagging_rules %}
            Automatically adds tags to bookmarks based on predefined rules.
            Each line is a single rule that maps a URL to one or more tags. For example:
            <pre>youtube.com video
reddit.com/r/Music music reddit</pre>
          {% endformhelp %}
        </div>
        <div class="form-group">
          {% formfield form.enable_favicons label="Enable Favicons" has_help=True %}
          {% formhelp form.enable_favicons %}
            Automatically loads favicons for bookmarked websites and displays them next to each bookmark.
            Enabling this feature automatically downloads all missing favicons.
            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://linkding.link/options/#ld_favicon_provider"
               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.
          {% endformhelp %}
          {% if request.user_profile.enable_favicons and enable_refresh_favicons %}
            <button class="btn mt-2" name="refresh_favicons">Refresh Favicons</button>
          {% endif %}
        </div>
        <div class="form-group">
          {% formfield form.enable_preview_images label="Enable Preview Images" has_help=True %}
          {% formhelp form.enable_preview_images %}
            Automatically loads preview images for bookmarked websites and displays them next to each bookmark.
            Enabling this feature automatically downloads all missing preview images.
          {% endformhelp %}
        </div>
        <div class="form-group">
          {% formlabel form.web_archive_integration "Internet Archive integration" %}
          {% formfield form.web_archive_integration has_help=True class="width-25 width-sm-100" %}
          {% formhelp form.web_archive_integration %}
            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" target="_blank" rel="noopener">Internet Archive</a> if you make use of this feature.
          {% endformhelp %}
        </div>
        <div class="form-group">
          {% formfield form.enable_sharing label="Enable bookmark sharing" has_help=True %}
          {% formhelp form.enable_sharing %}
            Allows to share bookmarks with other users, and to view shared bookmarks.
            Disabling this feature will hide all previously shared bookmarks from other users.
          {% endformhelp %}
        </div>
        <div class="form-group">
          {% formfield form.enable_public_sharing label="Enable public bookmark sharing" has_help=True %}
          {% formhelp form.enable_public_sharing %}
            Makes shared bookmarks publicly accessible, without requiring a login.
            That means that anyone with a link to this instance can view shared bookmarks via the <a href="{% url 'linkding:bookmarks.shared' %}">shared bookmarks page</a>.
          {% endformhelp %}
        </div>
        {% if has_snapshot_support %}
          <div class="form-group">
            {% formfield form.enable_automatic_html_snapshots label="Automatically create HTML snapshots" has_help=True %}
            {% formhelp form.enable_automatic_html_snapshots %}
              Automatically creates HTML snapshots when adding bookmarks. Alternatively, when disabled, snapshots can be
              created manually in the details view of a bookmark.
            {% endformhelp %}
            <button class="btn mt-2" name="create_missing_html_snapshots">Create missing HTML snapshots</button>
          </div>
        {% endif %}
        <div class="form-group">
          {% formfield form.default_mark_unread label="Create bookmarks as unread by default" has_help=True %}
          {% formhelp form.default_mark_unread %}
            Sets the default state for the "Mark as unread" option when creating a new bookmark.
            Setting this option will make all new bookmarks default to unread.
            This can be overridden when creating each new bookmark.
          {% endformhelp %}
        </div>
        <div class="form-group">
          {% formfield form.default_mark_shared label="Create bookmarks as shared by default" has_help=True %}
          {% formhelp form.default_mark_shared %}
            Sets the default state for the "Share" option when creating a new bookmark.
            Setting this option will make all new bookmarks default to shared.
            This can be overridden when creating each new bookmark.
          {% endformhelp %}
        </div>
        <div class="form-group">
          <details {% if form.custom_css.value %}open{% endif %}>
            <summary>
              <span class="form-label d-inline-block">Custom CSS</span>
            </summary>
            <label for="{{ form.custom_css.id_for_label }}" class="text-assistive">Custom CSS</label>
            <div>{% formfield form.custom_css has_help=True class="monospace" rows="6" %}</div>
          </details>
          {% formhelp form.custom_css %}
            Allows to add custom CSS to the page.
          {% endformhelp %}
        </div>
        <div class="form-group">
          <input type="submit"
                 name="update_profile"
                 value="Save"
                 class="btn btn-primary btn-wide mt-2">
        </div>
      </form>
    </section>
    {# Global settings section #}
    {% if global_settings_form %}
      <section aria-labelledby="global-settings-heading">
        <h2 id="global-settings-heading">Global settings</h2>
        <form action="{% url 'linkding:settings.update' %}"
              method="post"
              novalidate
              data-turbo="false">
          {% csrf_token %}
          <div class="form-group">
            {% formlabel global_settings_form.landing_page "Landing page" %}
            {% formfield global_settings_form.landing_page has_help=True class="width-25 width-sm-100" %}
            {% formhelp global_settings_form.landing_page %}
              The page that unauthenticated users are redirected to when accessing the root URL.
            {% endformhelp %}
          </div>
          <div class="form-group">
            {% formlabel global_settings_form.guest_profile_user "Guest user profile" %}
            {% formfield global_settings_form.guest_profile_user has_help=True class="width-25 width-sm-100" %}
            {% formhelp global_settings_form.guest_profile_user %}
              The user profile to use for users that are not logged in. This will affect how publicly shared bookmarks
              are displayed regarding theme, bookmark list settings, etc. You can either use your own profile or create
              a dedicated user for this purpose. By default, a standard profile with fixed settings is used.
            {% endformhelp %}
          </div>
          <div class="form-group">
            {% formfield global_settings_form.enable_link_prefetch label="Enable prefetching links on hover" has_help=True %}
            {% formhelp global_settings_form.enable_link_prefetch %}
              Prefetches internal links when hovering over them. This can improve the perceived performance when
              navigating application, but also increases the load on the server as well as bandwidth usage.
            {% endformhelp %}
          </div>
          <div class="form-group">
            <input type="submit"
                   name="update_global_settings"
                   value="Save"
                   class="btn btn-primary btn-wide mt-2">
          </div>
        </form>
      </section>
    {% endif %}
    {# Import section #}
    <section aria-labelledby="import-heading">
      <h2 id="import-heading">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 'linkding:settings.import' %}">
        {% csrf_token %}
        <div class="form-group">
          <label for="import_map_private_flag" class="form-checkbox">
            <input type="checkbox"
                   id="import_map_private_flag"
                   name="map_private_flag"
                   aria-describedby="import_map_private_flag_help">
            <i class="form-icon"></i> Import public bookmarks as shared
          </label>
          <div id="import_map_private_flag_help" class="form-input-hint">
            When importing bookmarks from a service that supports marking bookmarks as public or private (using the
            <code>PRIVATE</code> attribute), enabling this option will import all bookmarks that are marked as not
            private as shared bookmarks.
            Otherwise, all bookmarks will be imported as private bookmarks.
          </div>
        </div>
        <div class="form-group">
          <div class="input-group width-75 width-md-100">
            <input class="form-input" type="file" name="import_file">
            <input type="submit" class="input-group-btn btn btn-primary" value="Upload">
          </div>
        </div>
      </form>
    </section>
    {# Export section #}
    <section aria-labelledby="export-heading">
      <h2 id="export-heading">Export</h2>
      <p>Export all bookmarks in Netscape HTML format.</p>
      <a class="btn btn-primary"
         target="_blank"
         href="{% url 'linkding: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="about" aria-labelledby="about-heading">
      <h2 id="about-heading">About</h2>
      <table class="table">
        <tbody>
          <tr>
            <td>Version</td>
            <td>{{ version_info }}</td>
          </tr>
          <tr>
            <td style="vertical-align: top">Links</td>
            <td>
              <div class="d-flex flex-column gap-2">
                <a href="https://github.com/sissbruecker/linkding/" target="_blank">GitHub</a>
                <a href="https://linkding.link/" target="_blank">Documentation</a>
                <a href="https://github.com/sissbruecker/linkding/blob/master/CHANGELOG.md"
                   target="_blank">Changelog</a>
              </div>
            </td>
          </tr>
        </tbody>
      </table>
    </section>
  </main>
  <script>
    (function init() {
      const enableSharing = document.getElementById("{{ form.enable_sharing.id_for_label }}");
      const enablePublicSharing = document.getElementById("{{ form.enable_public_sharing.id_for_label }}");
      const defaultMarkShared = document.getElementById("{{ form.default_mark_shared.id_for_label }}");
      const bookmarkDescriptionDisplay = document.getElementById("{{ form.bookmark_description_display.id_for_label }}");
      const bookmarkDescriptionMaxLines = document.getElementById("{{ form.bookmark_description_max_lines.id_for_label }}");

      // Automatically disable public bookmark sharing and default shared option if bookmark sharing is disabled
      function updateSharingOptions() {
        if (enableSharing.checked) {
          enablePublicSharing.disabled = false;
          defaultMarkShared.disabled = false;
        } else {
          enablePublicSharing.disabled = true;
          enablePublicSharing.checked = false;
          defaultMarkShared.disabled = true;
          defaultMarkShared.checked = false;
        }
      }

      updateSharingOptions();
      enableSharing.addEventListener("change", updateSharingOptions);

      // Automatically hide the bookmark description max lines input if the description display is set to inline
      function updateBookmarkDescriptionMaxLines() {
        if (bookmarkDescriptionDisplay.value === "inline") {
          bookmarkDescriptionMaxLines.closest(".form-group").classList.add("d-hide");
        } else {
          bookmarkDescriptionMaxLines.closest(".form-group").classList.remove("d-hide");
        }
      }

      updateBookmarkDescriptionMaxLines();
      bookmarkDescriptionDisplay.addEventListener("change", updateBookmarkDescriptionMaxLines);
    })();
  </script>
{% endblock %}


================================================
FILE: bookmarks/templates/settings/integrations.html
================================================
{% extends "shared/layout.html" %}
{% block head %}
  {% with page_title="Integrations - Linkding" %}{{ block.super }}{% endwith %}
{% endblock %}
{% block content %}
  <main class="settings-page" aria-labelledby="main-heading">
    <h1 id="main-heading">Integrations</h1>
    <section aria-labelledby="browser-extension-heading">
      <h2 id="browser-extension-heading">Browser Extension</h2>
      <p>
        The browser extension allows you to quickly add new bookmarks without leaving the page that you are on. The
        extension is available in the official extension stores for:
      </p>
      <ul>
        <li>
          <a href="https://addons.mozilla.org/firefox/addon/linkding-extension/"
             target="_blank">Firefox</a>
        </li>
        <li>
          <a href="https://chrome.google.com/webstore/detail/linkding-extension/beakmhbijpdhipnjhnclmhgjlddhidpe"
             target="_blank">Chrome</a>
        </li>
      </ul>
      <p>
        The extension is <a href="https://github.com/sissbruecker/linkding-extension"
    target="_blank">open source</a>
        as well, which enables you to build and manually load it into any browser that supports Chrome extensions.
      </p>
      <h2>Bookmarklet</h2>
      <p>
        The bookmarklet is an alternative, cross-browser way to quickly add new bookmarks without opening the linkding
        application first. Here's how it works:
      </p>
      <ul>
        <li>
          Choose your preferred method for detecting website titles and descriptions below (<a href="https://linkding.link/troubleshooting/#automatically-detected-title-and-description-are-incorrect"
   target="_blank">Help</a>)
        </li>
        <li>Drag the bookmarklet below into your browser's bookmark bar / toolbar</li>
        <li>Open the website that you want to bookmark</li>
        <li>Click the bookmarklet in your browser's toolbar</li>
        <li>linkding opens in a new window or tab and allows you to add a bookmark for the site</li>
        <li>After saving the bookmark, the linkding window closes, and you are back on your website</li>
      </ul>
      <div class="form-group radio-group"
           role="radiogroup"
           aria-labelledby="detection-method-label">
        <p id="detection-method-label">Choose your preferred bookmarklet:</p>
        <label for="detection-method-server" class="form-radio">
          <input id="detection-method-server"
                 type="radio"
                 name="bookmarklet-type"
                 value="server"
                 checked>
          <i class="form-icon"></i>
          Detect title and description on the server
        </label>
        <label for="detection-method-client" class="form-radio">
          <input id="detection-method-client"
                 type="radio"
                 name="bookmarklet-type"
                 value="client">
          <i class="form-icon"></i>
          Detect title and description in the browser
        </label>
      </div>
      <div class="bookmarklet-container">
        <a id="bookmarklet-server"
           href="javascript: {% include 'settings/bookmarklet.js' %}"
           data-turbo="false"
           class="btn btn-primary">📎 Add bookmark</a>
        <a id="bookmarklet-client"
           href="javascript: {% include 'settings/bookmarklet_clientside.js' %}"
           data-turbo="false"
           class="btn btn-primary"
           style="display: none">📎 Add bookmark</a>
      </div>
      <script>
        (function init() {
          // Bookmarklet type toggle
          const radioButtons = document.querySelectorAll('input[name="bookmarklet-type"]');
          const serverBookmarklet = document.getElementById('bookmarklet-server');
          const clientBookmarklet = document.getElementById('bookmarklet-client');

          function toggleBookmarklet() {
            const selectedValue = document.querySelector('input[name="bookmarklet-type"]:checked').value;
            if (selectedValue === 'server') {
              serverBookmarklet.style.display = 'inline-block';
              clientBookmarklet.style.display = 'none';
            } else {
              serverBookmarklet.style.display = 'none';
              clientBookmarklet.style.display = 'inline-block';
            }
          }

          toggleBookmarklet();
          radioButtons.forEach(function(radio) {
            radio.addEventListener('change', toggleBookmarklet);
          });
        })();
      </script>
    </section>
    <turbo-frame id="api-section">
    <section aria-labelledby="rest-api-heading">
      <h2 id="rest-api-heading">REST API</h2>
      {% if api_success_message %}<div class="toast toast-success mb-2">{{ api_success_message }}</div>{% endif %}
      {% if api_token_name and api_token_key %}
        <div class="mt-4 mb-6">
          <p class="mb-2">
            <strong>Copy this token now, it will only be shown once:</strong>
          </p>
          <label class="text-assistive" for="new-token-key">New token key</label>
          <div class="input-group">
            <input class="form-input"
                   value="{{ api_token_key }}"
                   readonly
                   id="new-token-key">
            <button id="copy-new-token-key" class="btn input-group-btn" type="button">Copy</button>
          </div>
        </div>
      {% endif %}
      <p>
        API tokens can be used to authenticate 3rd-party applications against the REST API. <strong>Please treat
        tokens as you would any other credential.</strong> Any party with access to a token can access and manage all
        your bookmarks.
      </p>
      {% if api_tokens %}
        <form method="post"
              action="{% url 'linkding:settings.integrations.delete_api_token' %}"
              data-turbo-frame="api-section">
          <table class="table crud-table mb-6">
            <thead>
              <tr>
                <th>Name</th>
                <th>Created</th>
                <th class="actions">
                  <span class="text-assistive">Actions</span>
                </th>
              </tr>
            </thead>
            <tbody>
              {% for token in api_tokens %}
                <tr>
                  <td>{{ token.name }}</td>
                  <td>{{ token.created|date:"M d, Y H:i" }}</td>
                  <td class="actions">
                    {% csrf_token %}
                    <button data-confirm
                            name="token_id"
                            value="{{ token.id }}"
                            type="submit"
                            class="btn btn-link">Delete</button>
                  </td>
                </tr>
              {% endfor %}
            </tbody>
          </table>
        </form>
      {% endif %}
      <a class="btn"
         href="{% url 'linkding:settings.integrations.create_api_token' %}"
         data-turbo-frame="api-modal">Create API token</a>
    </section>
    <turbo-frame id="api-modal"></turbo-frame>
    <script>
      (function init() {
        // Copy new token key to clipboard
        const copyButton = document.getElementById('copy-new-token-key');
        if (copyButton) {
          copyButton.addEventListener('click', () => {
            const tokenInput = document.getElementById('new-token-key');
            const tokenValue = tokenInput.value;
            navigator.clipboard.writeText(tokenValue).then(() => {
              copyButton.textContent = 'Copied!';
              setTimeout(() => {
                copyButton.textContent = 'Copy';
              }, 2000);
            }, (err) => {
              console.error('Could not copy text: ', err);
            });
          });
        }
      })();
    </script>
    </turbo-frame>
    <section aria-labelledby="rss-feeds-heading">
      <h2 id="rss-feeds-heading">RSS Feeds</h2>
      <p>The following URLs provide RSS feeds for your bookmarks:</p>
      <ul style="list-style-position: outside;">
        <li>
          <a target="_blank" href="{{ all_feed_url }}">All bookmarks</a>
        </li>
        <li>
          <a target="_blank" href="{{ unread_feed_url }}">Unread bookmarks</a>
        </li>
        <li>
          <a target="_blank" href="{{ shared_feed_url }}">Shared bookmarks</a>
        </li>
        <li>
          <a target="_blank" href="{{ public_shared_feed_url }}">Public shared bookmarks</a>
          <br>
          <span class="text-small text-secondary">The public shared feed does not contain an authentication token and can be shared with other people. Only shows shared bookmarks from users who have explicitly enabled public sharing.</span>
        </li>
      </ul>
      <p>All URLs support the following URL parameters:</p>
      <ul style="list-style-position: outside;">
        <li>
          A <code>limit</code> parameter for specifying the maximum number of bookmarks to include in the feed. By
          default, only the latest 100 matching bookmarks are included.
        </li>
        <li>
          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.
        </li>
        <li>
          An <code>unread</code> parameter for filtering for unread or read bookmarks. Use <code>yes</code> for unread
          bookmarks and <code>no</code> for read bookmarks.
        </li>
        <li>
          A <code>shared</code> parameter for filtering for shared or unshared bookmarks. Use <code>yes</code> for
          shared bookmarks and <code>no</code> for unshared bookmarks.
        </li>
      </ul>
      <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 target="_blank"
    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>
  </main>
{% endblock %}


================================================
FILE: bookmarks/templates/shared/dev_tool.html
================================================
{% load shared %}
{% if debug and request.user.is_authenticated %}
  {{ request.user.profile|model_to_dict|json_script:"json_profile" }}
  <ld-dev-tool id="dev-tool"
               data-csrf-token="{{ csrf_token }}"
               data-form-action="{% url 'linkding:settings.update' %}"
               data-turbo-permanent>
  </ld-dev-tool>
{% endif %}


================================================
FILE: bookmarks/templates/shared/error_list.html
================================================
{% load i18n %}
{# Force rendering validation errors in English language to align with the rest of the app #}
{% language 'en-us' %}
  {% if errors %}
    <ul class="{{ error_class }} form-input-hint is-error"
        {% if errors.field_id %}id="{{ errors.field_id }}_error"{% endif %}>
      {% for error in errors %}<li>{{ error }}</li>{% endfor %}
    </ul>
  {% endif %}
{% endlanguage %}


================================================
FILE: bookmarks/templates/shared/head.html
================================================
{% load static %}
<head>
  <meta charset="UTF-8">
  <link rel="icon" href="{% static 'favicon.ico' %}" sizes="48x48">
  <link rel="icon"
        href="{% static 'favicon.svg' %}"
        sizes="any"
        type="image/svg+xml">
  <link rel="apple-touch-icon"
        sizes="180x180"
        href="{% static 'apple-touch-icon.png' %}">
  <link rel="mask-icon"
        href="{% static 'safari-pinned-tab.svg' %}"
        color="#5856e0">
  <link rel="manifest" href="{% url 'linkding:manifest' %}">
  <link rel="search"
        type="application/opensearchdescription+xml"
        title="Linkding"
        href="{% url 'linkding:opensearch' %}" />
  <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>{{ page_title|default:'Linkding' }}</title>
  {# Include specific theme variant based on user profile setting #}
  {% if request.user_profile.theme == 'light' %}
    <link href="{% static 'theme-light.css' %}?v={{ app_version }}"
          rel="stylesheet"
          type="text/css" />
    <meta name="theme-color" content="#5856e0">
  {% elif request.user_profile.theme == 'dark' %}
    <link href="{% static 'theme-dark.css' %}?v={{ app_version }}"
          rel="stylesheet"
          type="text/css" />
    <meta name="theme-color" content="#161822">
  {% else %}
    {# Use auto theme as fallback #}
    <link href="{% static 'theme-dark.css' %}?v={{ app_version }}"
          rel="stylesheet"
          type="text/css"
          media="(prefers-color-scheme: dark)" />
    <link href="{% static 'theme-light.css' %}?v={{ app_version }}"
          rel="stylesheet"
          type="text/css"
          media="(prefers-color-scheme: light)" />
    <meta name="theme-color"
          media="(prefers-color-scheme: dark)"
          content="#161822">
    <meta name="theme-color"
          media="(prefers-color-scheme: light)"
          content="#5856e0">
  {% endif %}
  {% if request.user_profile.custom_css %}
    <link href="{% url 'linkding:custom_css' %}?hash={{ request.user_profile.custom_css_hash }}"
          rel="stylesheet"
          type="text/css" />
  {% endif %}
  <meta name="turbo-cache-control" content="no-preview">
  {% if not request.global_settings.enable_link_prefetch %}<meta name="turbo-prefetch" content="false">{% endif %}
  {% if rss_feed_url %}<link rel="alternate" type="application/rss+xml" href="{{ rss_feed_url }}" />{% endif %}
  <script src="{% static "bundle.js" %}?v={{ app_version }}"></script>
  {% if debug %}
    <script src="{% static "live-reload.js" %}"></script>
  {% endif %}
</head>


================================================
FILE: bookmarks/templates/shared/layout.html
================================================
{% load static %}
<!DOCTYPE html>
{# Use data attributes as storage for access in static scripts #}
<html lang="en" data-api-base-url="{% url 'linkding:api-root' %}">
  {% block head %}
    {% include 'shared/head.html' %}
  {% endblock %}
  <body>
    <header class="container">
      {% if has_toasts %}
        <div class="message-list">
          <form action="{% url 'linkding:toasts.acknowledge' %}?return_url={{ request.path | urlencode }}"
                method="post">
            {% csrf_token %}
            {% for toast in toast_messages %}
              <div class="toast d-flex">
                {{ toast.message }}
                <button type="submit"
                        name="toast"
                        value="{{ toast.id }}"
                        class="btn btn-clear"></button>
              </div>
            {% endfor %}
          </form>
        </div>
      {% endif %}
      <div class="d-flex justify-between">
        <a href="{% url 'linkding:root' %}" class="app-link d-flex align-center">
          <img class="app-logo" src="{% static 'logo.png' %}" alt="Application logo">
          <span class="app-name">LINKDING</span>
        </a>
        <nav>
          {% if request.user.is_authenticated %}
            {# Only show nav items menu when logged in #}
            {% include 'shared/nav_menu.html' %}
          {% else %}
            {# Otherwise show login link #}
            <a href="{% url 'login' %}" class="btn btn-link">Login</a>
          {% endif %}
        </nav>
      </div>
    </header>
    <div class="content container">
      {% block content %}{% endblock %}
    </div>
    <div class="modals">
      {% block overlays %}{% endblock %}
    </div>
    {% include 'shared/dev_tool.html' %}
  </body>
</html>


================================================
FILE: bookmarks/templates/shared/messages.html
================================================
{% if messages %}
  <div class="message-list">
    {% for message in messages %}<div class="toast toast-{{ message.tags }}" role="alert">{{ message }}</div>{% endfor %}
  </div>
{% endif %}


================================================
FILE: bookmarks/templates/shared/modal_header.html
================================================
{% load static %}
<div class="modal-header">
  <h2 class="title">{{ title }}</h2>
  <button type="button"
          class="btn btn-noborder close"
          aria-label="Close dialog"
          data-close-modal>
    <svg width="24" height="24">
      <use href="{% static 'icons.svg' %}?v={{ app_version }}#close"></use>
    </svg>
  </button>
</div>


================================================
FILE: bookmarks/templates/shared/nav_menu.html
================================================
{% load shared static %}
{% htmlmin %}
{# Basic menu list #}
<div class="hide-md">
  <a href="{% url 'linkding:bookmarks.new' %}"
     class="btn btn-primary mr-2">Add bookmark</a>
  <ld-dropdown class="dropdown">
    <button class="btn btn-link dropdown-toggle" tabindex="0">Bookmarks</button>
    <ul class="menu" role="list" tabindex="-1">
      <li class="menu-item">
        <a href="{% url 'linkding:bookmarks.index' %}" class="menu-link">Active</a>
      </li>
      <li class="menu-item">
        <a href="{% url 'linkding:bookmarks.archived' %}" class="menu-link">Archived</a>
      </li>
      {% if request.user_profile.enable_sharing %}
        <li class="menu-item">
          <a href="{% url 'linkding:bookmarks.shared' %}" class="menu-link">Shared</a>
        </li>
      {% endif %}
      <li class="menu-item">
        <a href="{% url 'linkding:bookmarks.index' %}?unread=yes"
           class="menu-link">Unread</a>
      </li>
      <li class="menu-item">
        <a href="{% url 'linkding:bookmarks.index' %}?q=!untagged"
           class="menu-link">Untagged</a>
      </li>
    </ul>
  </ld-dropdown>
  <ld-dropdown class="dropdown">
    <button class="btn btn-link dropdown-toggle" tabindex="0">Settings</button>
    <ul class="menu" role="list" tabindex="-1">
      <li class="menu-item">
        <a href="{% url 'linkding:settings.general' %}" class="menu-link">General</a>
      </li>
      <li class="menu-item">
        <a href="{% url 'linkding:settings.integrations' %}" class="menu-link">Integrations</a>
      </li>
      {% if request.user.is_superuser %}
        <li class="menu-item">
          <a href="{% url 'admin:index' %}" class="menu-link" data-turbo="false">Admin</a>
        </li>
      {% endif %}
    </ul>
  </ld-dropdown>
  <form class="d-inline"
        action="{% url 'logout' %}"
        method="post"
        data-turbo="false">
    {% csrf_token %}
    <button type="submit" class="btn btn-link">Logout</button>
  </form>
</div>
{# Menu drop-down for smaller devices #}
<div class="show-md">
  <a href="{% url 'linkding:bookmarks.new' %}"
     aria-label="Add bookmark"
     class="btn btn-primary">
    <svg width="24" height="24">
      <use href="{% static 'icons.svg' %}?v={{ app_version }}#plus"></use>
    </svg>
  </a>
  <ld-dropdown class="dropdown dropdown-right">
    <button class="btn btn-link dropdown-toggle"
            aria-label="Navigation menu"
            tabindex="0">
      <svg width="24" height="24">
        <use href="{% static 'icons.svg' %}?v={{ app_version }}#menu"></use>
      </svg>
    </button>
    <!-- menu component -->
    <ul class="menu" role="list" tabindex="-1">
      <li class="menu-item">
        <a href="{% url 'linkding:bookmarks.index' %}" class="menu-link">Bookmarks</a>
      </li>
      <li class="menu-item">
        <a href="{% url 'linkding:bookmarks.archived' %}" class="menu-link">Archived bookmarks</a>
      </li>
      {% if request.user_profile.enable_sharing %}
        <li class="menu-item">
          <a href="{% url 'linkding:bookmarks.shared' %}" class="menu-link">Shared bookmarks</a>
        </li>
      {% endif %}
      <li class="menu-item">
        <a href="{% url 'linkding:bookmarks.index' %}?unread=yes"
           class="menu-link">Unread</a>
      </li>
      <li class="menu-item">
        <a href="{% url 'linkding:bookmarks.index' %}?q=!untagged"
           class="menu-link">Untagged</a>
      </li>
      <div class="divider"></div>
      <li class="menu-item">
        <a href="{% url 'linkding:settings.general' %}" class="menu-link">Settings</a>
      </li>
      <li class="menu-item">
        <a href="{% url 'linkding:settings.integrations' %}" class="menu-link">Integrations</a>
      </li>
      {% if request.user.is_superuser %}
        <li class="menu-item">
          <a href="{% url 'admin:index' %}" class="menu-link" data-turbo="false">Admin</a>
        </li>
      {% endif %}
      <div class="divider"></div>
      <li class="menu-item">
        <form class="d-inline"
              action="{% url 'logout' %}"
              method="post"
              data-turbo="false">
          {% csrf_token %}
          <button type="submit" class="btn btn-link menu-link">Logout</button>
        </form>
      </li>
    </ul>
  </ld-dropdown>
</div>
{% endhtmlmin %}


================================================
FILE: bookmarks/templates/shared/pagination.html
================================================
{% load shared %}
<ul class="pagination">
  {% if prev_link %}
    <li class="page-item">
      <a href="{{ prev_link }}"
         tabindex="-1"
         data-turbo-frame="{{ pagination_frame }}">Previous</a>
    </li>
  {% else %}
    <li class="page-item disabled">
      <a href="#" tabindex="-1">Previous</a>
    </li>
  {% endif %}
  {% for page_link in page_links %}
    {% if page_link %}
      <li class="page-item {% if page_link.active %}active{% endif %}">
        <a href="{{ page_link.link }}" data-turbo-frame="{{ pagination_frame }}">{{ page_link.number }}</a>
      </li>
    {% else %}
      <li class="page-item">
        <span>...</span>
      </li>
    {% endif %}
  {% endfor %}
  {% if next_link %}
    <li class="page-item">
      <a href="{{ next_link }}"
         tabindex="-1"
         data-turbo-frame="{{ pagination_frame }}">Next</a>
    </li>
  {% else %}
    <li class="page-item disabled">
      <a href="#" tabindex="-1">Next</a>
    </li>
  {% endif %}
</ul>


================================================
FILE: bookmarks/templates/shared/top_frame.html
================================================
<html lang="en">
  {% include 'shared/head.html' %}
  <body>
    <!--content-->
  </body>
</html>


================================================
FILE: bookmarks/templates/tags/edit.html
================================================
<turbo-frame id="tag-modal">
<form method="post"
      action="{% url 'linkding:tags.edit' tag.id %}?{{ request.GET.urlencode }}"
      data-turbo-frame="tag-main"
      novalidate>
  {% csrf_token %}
  <ld-modal class="modal tag-edit-modal active"
            data-close-url="{% url 'linkding:tags.index' %}?{{ request.GET.urlencode }}"
            data-turbo-frame="tag-modal">
    <div class="modal-overlay" data-close-modal></div>
    <div class="modal-container" role="dialog" aria-modal="true">
      {% include 'shared/modal_header.html' with title="Edit Tag" %}
      <div class="modal-body">{% include 'tags/form.html' %}</div>
      <div class="modal-footer d-flex justify-between">
        <button type="button" class="btn btn-wide" data-close-modal>Cancel</button>
        <button type="submit" class="btn btn-primary btn-wide">Save</button>
      </div>
    </div>
  </ld-modal>
</form>
</turbo-frame>


================================================
FILE: bookmarks/templates/tags/form.html
================================================
{% load shared %}
<div class="form-group">
  {% formlabel form.name "Name" %}
  {% formfield form.name has_help=True autofocus=True %}
  {% formhelp form.name %}
    Tag names are case-insensitive and cannot contain spaces (spaces will be replaced with hyphens).
  {% endformhelp %}
  {{ form.name.errors }}
</div>


================================================
FILE: bookmarks/templates/tags/index.html
================================================
{% extends "shared/layout.html" %}
{% load shared static pagination %}
{% block head %}
  {% with page_title="Tags - Linkding" %}{{ block.super }}{% endwith %}
{% endblock %}
{% block content %}
  <div class="tags-page crud-page">
    <turbo-frame id="tag-main">
    <main aria-labelledby="main-heading">
      <div class="crud-header">
        <h1 id="main-heading">Tags</h1>
        <div class="d-flex gap-2 ml-auto">
          <a href="{% url 'linkding:tags.new' %}"
             data-turbo-frame="tag-modal"
             class="btn">Create Tag</a>
          <a href="{% url 'linkding:tags.merge' %}"
             data-turbo-frame="tag-modal"
             class="btn">Merge Tags</a>
        </div>
      </div>
      {% include 'shared/messages.html' %}
      {# Filters #}
      <div class="crud-filters">
        <ld-form data-form-reset>
          <form method="get" class="mb-2" data-turbo-frame="_top">
            <div class="form-group">
              <label class="form-label text-assistive" for="search">Search tags</label>
              <div class="input-group">
                <input type="text"
                       id="search"
                       name="search"
                       value="{{ search }}"
                       placeholder="Search tags..."
                       class="form-input">
                <button type="submit" class="btn input-group-btn">Search</button>
              </div>
            </div>
            <div class="form-group">
              <label class="form-label text-assistive" for="sort">Sort by</label>
              <div class="input-group">
                <span class="input-group-addon text-secondary">
                  <svg width="20" height="20">
                    <use href="{% static 'icons.svg' %}?v={{ app_version }}#sort"></use>
                  </svg>
                </span>
                <select id="sort" name="sort" class="form-select" data-submit-on-change>
                  <option value="name-asc" {% if sort == "name-asc" %}selected{% endif %}>Name A-Z</option>
                  <option value="name-desc" {% if sort == "name-desc" %}selected{% endif %}>Name Z-A</option>
                  <option value="count-asc" {% if sort == "count-asc" %}selected{% endif %}>Fewest bookmarks</option>
                  <option value="count-desc" {% if sort == "count-desc" %}selected{% endif %}>Most bookmarks</option>
                </select>
              </div>
            </div>
            <div class="form-group">
              <label class="form-checkbox">
                <input type="checkbox"
                       name="unused"
                       value="true"
                       {% if unused_only %}checked{% endif %}
                       data-submit-on-change>
                <i class="form-icon"></i> Show only unused tags
              </label>
            </div>
          </form>
        </ld-form>
        {# Tags count #}
        <p class="text-secondary text-small m-0">
          {% if search or unused_only %}
            Showing {{ page.paginator.count }} of {{ total_tags }} tags
          {% else %}
            {{ total_tags }} tags total
          {% endif %}
        </p>
      </div>
      {# Tags List #}
      {% if page.object_list %}
        <form method="post">
          {% csrf_token %}
          <table class="table crud-table">
            <thead>
              <tr>
                <th>Name</th>
                <th style="width: 25%">Bookmarks</th>
                <th class="actions">
                  <span class="text-assistive">Actions</span>
                </th>
              </tr>
            </thead>
            <tbody>
              {% for tag in page.object_list %}
                <tr>
                  <td>{{ tag.name }}</td>
                  <td style="width: 25%">
                    <a class="btn btn-link"
                       href="{% url 'linkding:bookmarks.index' %}?q=%23{{ tag.name|urlencode }}">
                      {{ tag.bookmark_count }}
                    </a>
                  </td>
                  <td class="actions">
                    <a class="btn btn-link"
                       href="{% url 'linkding:tags.edit' tag.id %}?{{ request.GET.urlencode }}"
                       data-turbo-frame="tag-modal">Edit</a>
                    <button type="submit"
                            name="delete_tag"
                            value="{{ tag.id }}"
                            class="btn btn-link text-error"
                            data-confirm>Remove</button>
                  </td>
                </tr>
              {% endfor %}
            </tbody>
          </table>
        </form>
        {% pagination page %}
      {% else %}
        <div class="empty">
          {% if search or unused_only %}
            <p class="empty-title h5">No tags found</p>
            <p class="empty-subtitle">Try adjusting your search or filters</p>
          {% else %}
            <p class="empty-title h5">You have no tags yet</p>
            <p class="empty-subtitle">Tags will appear here when you add bookmarks with tags</p>
          {% endif %}
        </div>
      {% endif %}
    </main>
    <turbo-frame id="tag-modal"></turbo-frame>
    </turbo-frame>
  </div>
{% endblock %}


================================================
FILE: bookmarks/templates/tags/merge.html
================================================
{% load shared %}
<turbo-frame id="tag-modal">
<form method="post"
      action="{% url 'linkding:tags.merge' %}"
      data-turbo-frame="_top"
      novalidate>
  {% csrf_token %}
  <ld-modal class="modal active"
            data-close-url="{% url 'linkding:tags.index' %}"
            data-turbo-frame="tag-modal">
    <div class="modal-overlay" data-close-modal></div>
    <div class="modal-container" role="dialog" aria-modal="true">
      {% include 'shared/modal_header.html' with title="Merge Tags" %}
      <div class="modal-body">
        <details class="mb-4">
          <summary>
            <span class="text-bold mb-1">How to merge tags</span>
          </summary>
          <ol>
            <li>Enter the name of the tag you want to keep</li>
            <li>Enter the names of tags to merge into the target tag</li>
            <li>The target tag is added to all bookmarks that have any of the merge tags</li>
            <li>The merged tags are deleted</li>
          </ol>
        </details>
        <div class="form-group">
          {% formlabel form.target_tag "Target tag" %}
          {% formfield form.target_tag has_help=True %}
          {% formhelp form.target_tag %}
            Enter the name of the tag you want to keep. The tags entered below will be merged into this one.
          {% endformhelp %}
          {{ form.target_tag.errors }}
        </div>
        <div class="form-group">
          {% formlabel form.merge_tags "Tags to merge" %}
          {% formfield form.merge_tags has_help=True %}
          {% formhelp form.merge_tags %}
            Enter the names of tags to merge into the target tag, separated by spaces.
            These tags will be deleted after merging.
          {% endformhelp %}
          {{ form.merge_tags.errors }}
        </div>
      </div>
      <div class="modal-footer d-flex justify-between">
        <button type="button" class="btn btn-wide" data-close-modal>Cancel</button>
        <button type="submit" class="btn btn-primary btn-wide">Merge Tags</button>
      </div>
    </div>
  </ld-modal>
</form>
</turbo-frame>


================================================
FILE: bookmarks/templates/tags/new.html
================================================
<turbo-frame id="tag-modal">
<form method="post"
      action="{% url 'linkding:tags.new' %}"
      data-turbo-frame="_top"
      novalidate>
  {% csrf_token %}
  <ld-modal class="modal tag-edit-modal active"
            data-close-url="{% url 'linkding:tags.index' %}"
            data-turbo-frame="tag-modal">
    <div class="modal-overlay" data-close-modal></div>
    <div class="modal-container" role="dialog" aria-modal="true">
      {% include 'shared/modal_header.html' with title="Create Tag" %}
      <div class="modal-body">{% include 'tags/form.html' %}</div>
      <div class="modal-footer d-flex justify-between">
        <button type="button" class="btn btn-wide" data-close-modal>Cancel</button>
        <button type="submit" class="btn btn-primary btn-wide">Save</button>
      </div>
    </div>
  </ld-modal>
</form>
</turbo-frame>


================================================
FILE: bookmarks/templatetags/__init__.py
================================================


================================================
FILE: bookmarks/templatetags/bookmarks.py
================================================
from django import template

from bookmarks.forms import BookmarkSearchForm
from bookmarks.models import BookmarkSearch

register = template.Library()


@register.inclusion_tag(
    "bookmarks/search.html", name="bookmark_search", takes_context=True
)
def bookmark_search(context, search: BookmarkSearch, mode: str = ""):
    search_form = BookmarkSearchForm(search, editable_fields=["q"])

    if mode == "shared":
        preferences_form = BookmarkSearchForm(search, editable_fields=["sort"])
    else:
        preferences_form = BookmarkSearchForm(
            search, editable_fields=["sort", "shared", "unread"]
        )
    return {
        "request": context["request"],
        "app_version": context["app_version"],
        "search": search,
        "search_form": search_form,
        "preferences_form": preferences_form,
        "mode": mode,
    }


================================================
FILE: bookmarks/templatetags/pagination.py
================================================
from functools import reduce

from django import template
from django.core.paginator import Page
from django.http import QueryDict

NUM_ADJACENT_PAGES = 2

register = template.Library()


@register.inclusion_tag("shared/pagination.html", name="pagination", takes_context=True)
def pagination(context, page: Page):
    request = context["request"]
    pagination_frame = context.get("pagination_frame", "_top")
    base_url = request.path

    # remove page number and details from query parameters
    query_params = request.GET.copy()
    query_params.pop("page", None)
    query_params.pop("details", None)

    prev_link = (
        _generate_link(base_url, query_params, page.previous_page_number())
        if page.has_previous()
        else None
    )
    next_link = (
        _generate_link(base_url, query_params, page.next_page_number())
        if page.has_next()
        else None
    )

    visible_page_numbers = get_visible_page_numbers(
        page.number, page.paginator.num_pages
    )
    page_links = []
    for page_number in visible_page_numbers:
        if page_number == -1:
            page_links.append(None)
        else:
            link = _generate_link(base_url, query_params, page_number)
            page_links.append(
                {
                    "active": page_number == page.number,
                    "number": page_number,
                    "link": link,
                }
            )

    return {
        "prev_link": prev_link,
        "next_link": next_link,
        "page_links": page_links,
        "pagination_frame": pagination_frame,
    }


def get_visible_page_numbers(current_page_number: int, num_pages: int) -> [int]:
    """
    Generates a list of page indexes that should be rendered
    The list can contain "holes" which indicate that a range of pages are truncated
    Holes are indicated with a value of `-1`
    :param current_page_number:
    :param num_pages:
    """
    visible_pages = set()

    # Add adjacent pages around current page
    visible_pages |= set(
        range(
            max(1, current_page_number - NUM_ADJACENT_PAGES),
            min(num_pages, current_page_number + NUM_ADJACENT_PAGES) + 1,
        )
    )

    # Add first page
    visible_pages.add(1)

    # Add last page
    visible_pages.add(num_pages)

    # Convert to sorted list
    visible_pages = list(visible_pages)
    visible_pages.sort()

    def append_page(result: [int], page_number: int):
        # Look for holes and insert a -1 as indicator
        is_hole = len(result) > 0 and result[-1] < page_number - 1
        if is_hole:
            result.append(-1)
        result.append(page_number)
        return result

    return reduce(append_page, visible_pages, [])


def _generate_link(base_url: str, query_params: QueryDict, page_number: int) -> str:
    query_params = query_params.copy()
    query_params["page"] = page_number
    return f"{base_url}?{query_params.urlencode()}"


================================================
FILE: bookmarks/templatetags/shared.py
================================================
import re

import bleach
import markdown
from bleach.linkifier import DEFAULT_CALLBACKS, Linker
from bleach_allowlist import markdown_attrs, markdown_tags
from django import template
from django.forms.models import model_to_dict
from django.utils.safestring import mark_safe

from bookmarks import utils
from bookmarks.widgets import FormCheckbox

register = template.Library()


@register.simple_tag(takes_context=True)
def update_query_string(context, **kwargs):
    query = context.request.GET.copy()

    # Replace query params with the ones from tag parameters
    for key in kwargs:
        query.__setitem__(key, kwargs[key])

    return query.urlencode()


@register.simple_tag(takes_context=True)
def replace_query_param(context, **kwargs):
    query = context.request.GET.copy()

    # Create query param or replace existing
    for key in kwargs:
        value = kwargs[key]
        query.__setitem__(key, value)

    return query.urlencode()


@register.filter(name="first_char")
def first_char(text):
    return text[0]


@register.filter(name="remaining_chars")
def remaining_chars(text, index):
    return text[index:]


@register.filter(name="humanize_absolute_date")
def humanize_absolute_date(value):
    if value in (None, ""):
        return ""
    return utils.humanize_absolute_date(value)


@register.filter(name="humanize_relative_date")
def humanize_relative_date(value):
    if value in (None, ""):
        return ""
    return utils.humanize_relative_date(value)


@register.filter(name="model_to_dict")
def model_to_dict_filter(value):
    result = model_to_dict(value)
    return result


@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


def schemeless_urls_to_https(attrs, _new):
    href_key = (None, "href")
    if href_key not in attrs:
        return attrs

    if attrs.get("_text", "").startswith("http://"):
        # The original text explicitly specifies http://, so keep it
        return attrs

    attrs[href_key] = re.sub(r"^http://", "https://", attrs[href_key])
    return attrs


linker = Linker(callbacks=[*DEFAULT_CALLBACKS, schemeless_urls_to_https])


@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 "markdown_renderer" not 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)
    linkified_html = linker.linkify(sanitized_html)

    return mark_safe(linkified_html)


def append_attr(widget, attr, value):
    attrs = widget.attrs
    if attrs.get(attr):
        attrs[attr] += " " + value
    else:
        attrs[attr] = value


@register.simple_tag
def formlabel(field, label_text):
    return mark_safe(
        f'<label for="{field.id_for_label}" class="form-label">{label_text}</label>'
    )


@register.simple_tag
def formfield(field, **kwargs):
    widget = field.field.widget

    label = kwargs.pop("label", None)
    if label and isinstance(widget, FormCheckbox):
        widget.label = label

    if kwargs.pop("has_help", False):
        append_attr(widget, "aria-describedby", field.auto_id + "_help")

    has_errors = hasattr(field, "errors") and field.errors
    if has_errors:
        append_attr(widget, "class", "is-error")
        append_attr(widget, "aria-describedby", field.auto_id + "_error")
    if field.field.required and not has_errors:
        append_attr(widget, "aria-invalid", "false")

    for attr, value in kwargs.items():
        attr = attr.replace("_", "-")
        if attr == "class":
            append_attr(widget, "class", value)
        else:
            widget.attrs[attr] = value

    return field.as_widget()


@register.tag
def formhelp(parser, token):
    try:
        tag_name, field_var = token.split_contents()
    except ValueError:
        raise template.TemplateSyntaxError(
            f"{token.contents.split()[0]!r} tag requires a single argument (form field)"
        ) from None
    nodelist = parser.parse(("endformhelp",))
    parser.delete_first_token()
    return FormHelpNode(nodelist, field_var)


class FormHelpNode(template.Node):
    def __init__(self, nodelist, field_var):
        self.nodelist = nodelist
        self.field_var = template.Variable(field_var)

    def render(self, context):
        field = self.field_var.resolve(context)
        content = self.nodelist.render(context)
        return f'<div id="{field.auto_id}_help" class="form-input-hint">{content}</div>'


================================================
FILE: bookmarks/tests/__init__.py
================================================


================================================
FILE: bookmarks/tests/helpers.py
================================================
import gzip
import logging
import os
import random
import shutil
import tempfile
from datetime import datetime
from unittest import TestCase

from bs4 import BeautifulSoup
from django.conf import settings
from django.test import override_settings
from django.utils import timezone
from django.utils.crypto import get_random_string
from rest_framework import status
from rest_framework.test import APITestCase

from bookmarks.models import (
    ApiToken,
    Bookmark,
    BookmarkAsset,
    BookmarkBundle,
    Tag,
    User,
)


class BookmarkFactoryMixin:
    user = None

    def setup_temp_assets_dir(self):
        self.assets_dir = tempfile.mkdtemp()
        self.settings_override = override_settings(LD_ASSET_FOLDER=self.assets_dir)
        self.settings_override.enable()
        self.addCleanup(self.cleanup_temp_assets_dir)

    def cleanup_temp_assets_dir(self):
        shutil.rmtree(self.assets_dir)
        self.settings_override.disable()

    def get_or_create_test_user(self):
        if self.user is None:
            self.user = User.objects.create_user(
                "testuser", "test@example.com", "password123"
            )

        return self.user

    def setup_superuser(self):
        return User.objects.create_superuser(
            "superuser", "superuser@example.com", "password123"
        )

    def setup_bookmark(
        self,
        is_archived: bool = False,
        unread: bool = False,
        shared: bool = False,
        tags=None,
        user: User = None,
        url: str = "",
        title: str = None,
        description: str = "",
        notes: str = "",
        web_archive_snapshot_url: str = "",
        favicon_file: str = "",
        preview_image_file: str = "",
        added: datetime = None,
        modified: datetime = None,
    ):
        if title is None:
            title = get_random_string(length=32)
        if tags is None:
            tags = []
        if user is None:
            user = self.get_or_create_test_user()
        if not url:
            unique_id = get_random_string(length=32)
            url = "https://example.com/" + unique_id
        if added is None:
            added = timezone.now()
        if modified is None:
            modified = timezone.now()
        bookmark = Bookmark(
            url=url,
            title=title,
            description=description,
            notes=notes,
            date_added=added,
            date_modified=modified,
            owner=user,
            is_archived=is_archived,
            unread=unread,
            shared=shared,
            web_archive_snapshot_url=web_archive_snapshot_url,
            favicon_file=favicon_file,
            preview_image_file=preview_image_file,
        )
        bookmark.save()
        for tag in tags:
            bookmark.tags.add(tag)
        bookmark.save()
        return bookmark

    def setup_numbered_bookmarks(
        self,
        count: int,
        prefix: str = "",
        suffix: str = "",
        tag_prefix: str = "",
        archived: bool = False,
        unread: bool = False,
        shared: bool = False,
        with_tags: bool = False,
        with_web_archive_snapshot_url: bool = False,
        with_favicon_file: bool = False,
        with_preview_image_file: bool = False,
        user: User = None,
    ):
        user = user or self.get_or_create_test_user()
        bookmarks = []

        if not prefix:
            if archived:
                prefix = "Archived Bookmark"
            elif shared:
                prefix = "Shared Bookmark"
            else:
                prefix = "Bookmark"

        if not tag_prefix:
            if archived:
                tag_prefix = "Archived Tag"
            elif shared:
                tag_prefix = "Shared Tag"
            else:
                tag_prefix = "Tag"

        for i in range(1, count + 1):
            title = f"{prefix} {i}{suffix}"
            url = f"https://example.com/{prefix}/{i}"
            tags = []
            if with_tags:
                tag_name = f"{tag_prefix} {i}{suffix}"
                tags = [self.setup_tag(name=tag_name, user=user)]
            web_archive_snapshot_url = ""
            if with_web_archive_snapshot_url:
                web_archive_snapshot_url = f"https://web.archive.org/web/{i}"
            favicon_file = ""
            if with_favicon_file:
                favicon_file = f"favicon_{i}.png"
            preview_image_file = ""
            if with_preview_image_file:
                preview_image_file = f"preview_image_{i}.png"
            bookmark = self.setup_bookmark(
                url=url,
                title=title,
                is_archived=archived,
                unread=unread,
                shared=shared,
                tags=tags,
                web_archive_snapshot_url=web_archive_snapshot_url,
                favicon_file=favicon_file,
                preview_image_file=preview_image_file,
                user=user,
            )
            bookmarks.append(bookmark)

        return bookmarks

    def get_numbered_bookmark(self, title: str):
        return Bookmark.objects.get(title=title)

    def setup_bundle(
        self,
        user: User = None,
        name: str = None,
        search: str = "",
        any_tags: str = "",
        all_tags: str = "",
        excluded_tags: str = "",
        filter_unread: str = BookmarkBundle.FILTER_STATE_OFF,
        filter_shared: str = BookmarkBundle.FILTER_STATE_OFF,
        order: int = 0,
    ):
        if user is None:
            user = self.get_or_create_test_user()
        if not name:
            name = get_random_string(length=32)
        bundle = BookmarkBundle(
            name=name,
            owner=user,
            date_created=timezone.now(),
            search=search,
            any_tags=any_tags,
            all_tags=all_tags,
            excluded_tags=excluded_tags,
            filter_unread=filter_unread,
            filter_shared=filter_shared,
            order=order,
        )
        bundle.save()
        return bundle

    def setup_asset(
        self,
        bookmark: Bookmark,
        date_created: datetime = None,
        file: str = None,
        file_size: int = None,
        asset_type: str = BookmarkAsset.TYPE_SNAPSHOT,
        content_type: str = "image/html",
        display_name: str = None,
        status: str = BookmarkAsset.STATUS_COMPLETE,
        gzip: bool = False,
    ):
        if date_created is None:
            date_created = timezone.now()
        if not file:
            file = get_random_string(length=32)
        if not display_name:
            display_name = file
        asset = BookmarkAsset(
            bookmark=bookmark,
            date_created=date_created,
            file=file,
            file_size=file_size,
            asset_type=asset_type,
            content_type=content_type,
            display_name=display_name,
            status=status,
            gzip=gzip,
        )
        asset.save()
        return asset

    def setup_asset_file(self, asset: BookmarkAsset, file_content: str = "test"):
        filepath = os.path.join(settings.LD_ASSET_FOLDER, asset.file)
        if asset.gzip:
            with gzip.open(filepath, "wb") as f:
                f.write(file_content.encode())
        else:
            with open(filepath, "w") as f:
                f.write(file_content)

    def read_asset_file(self, asset: BookmarkAsset):
        filepath = os.path.join(settings.LD_ASSET_FOLDER, asset.file)

        if asset.gzip:
            with gzip.open(filepath, "rb") as f:
                return f.read()
        else:
            with open(filepath, "rb") as f:
                return f.read()

    def get_asset_filesize(self, asset: BookmarkAsset):
        filepath = os.path.join(settings.LD_ASSET_FOLDER, asset.file)
        return os.path.getsize(filepath) if os.path.exists(filepath) else 0

    def has_asset_file(self, asset: BookmarkAsset):
        filepath = os.path.join(settings.LD_ASSET_FOLDER, asset.file)
        return os.path.exists(filepath)

    def setup_tag(self, user: User = None, name: str = ""):
        if user is None:
            user = self.get_or_create_test_user()
        if not name:
            name = get_random_string(length=32)
        tag = Tag(name=name, date_added=timezone.now(), owner=user)
        tag.save()
        return tag

    def setup_user(
        self,
        name: str = None,
        enable_sharing: bool = False,
        enable_public_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.enable_public_sharing = enable_public_sharing
        user.profile.save()
        return user

    def setup_api_token(self, user: User = None, name: str = ""):
        if user is None:
            user = self.get_or_create_test_user()
        if not name:
            name = get_random_string(length=32)
        token = ApiToken(user=user, name=name)
        token.save()
        return token

    def get_tags_from_bookmarks(self, bookmarks: list[Bookmark]):
        all_tags = []
        for bookmark in bookmarks:
            all_tags = all_tags + list(bookmark.tags.all())
        return all_tags

    def get_random_string(self, length: int = 32):
        return get_random_string(length=length)


class HtmlTestMixin:
    def make_soup(self, html: str):
        return BeautifulSoup(html, features="html.parser")


class BookmarkListTestMixin(TestCase, HtmlTestMixin):
    def assertVisibleBookmarks(
        self, response, bookmarks: list[Bookmark], link_target: str = "_blank"
    ):
        soup = self.make_soup(response.content.decode())
        bookmark_list = soup.select_one(
            f'ul.bookmark-list[data-bookmarks-total="{len(bookmarks)}"]'
        )
        self.assertIsNotNone(bookmark_list)

        bookmark_items = bookmark_list.select("ul.bookmark-list > li")
        self.assertEqual(len(bookmark_items), len(bookmarks))

        for bookmark in bookmarks:
            bookmark_item = bookmark_list.select_one(
                f'ul.bookmark-list > li a[href="{bookmark.url}"][target="{link_target}"]'
            )
            self.assertIsNotNone(bookmark_item)

    def assertInvisibleBookmarks(
        self, response, bookmarks: list[Bookmark], link_target: str = "_blank"
    ):
        soup = self.make_soup(response.content.decode())

        for bookmark in bookmarks:
            bookmark_item = soup.select_one(
                f'ul.bookmark-list > li a[href="{bookmark.url}"][target="{link_target}"]'
            )
            self.assertIsNone(bookmark_item)


class TagCloudTestMixin(TestCase, HtmlTestMixin):
    def assertVisibleTags(self, response, tags: list[Tag]):
        soup = self.make_soup(response.content.decode())
        tag_cloud = soup.select_one("div.tag-cloud")
        self.assertIsNotNone(tag_cloud)

        tag_items = tag_cloud.select("a[data-is-tag-item]")
        self.assertEqual(len(tag_items), len(tags))

        tag_item_names = [tag_item.text.strip() for tag_item in tag_items]

        for tag in tags:
            self.assertTrue(tag.name in tag_item_names)

    def assertInvisibleTags(self, response, tags: list[Tag]):
        soup = self.make_soup(response.content.decode())
        tag_items = soup.select("a[data-is-tag-item]")

        tag_item_names = [tag_item.text.strip() for tag_item in tag_items]

        for tag in tags:
            self.assertFalse(tag.name in tag_item_names)

    def assertSelectedTags(self, response, tags: list[Tag]):
        soup = self.make_soup(response.content.decode())
        selected_tags = soup.select_one("p.selected-tags")
        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}",
            )


class LinkdingApiTestCase(APITestCase):
    def authenticate(self):
        user = self.get_or_create_test_user()
        self.api_token = ApiToken(user=user, name="Test Token")
        self.api_token.save()
        self.client.credentials(HTTP_AUTHORIZATION="Token " + self.api_token.key)

    def get(self, url, expected_status_code=status.HTTP_200_OK):
        response = self.client.get(url)
        self.assertEqual(response.status_code, expected_status_code)
        return response

    def post(self, url, data=None, expected_status_code=status.HTTP_200_OK):
        response = self.client.post(url, data, format="json")
        self.assertEqual(response.status_code, expected_status_code)
        return response

    def put(self, url, data=None, expected_status_code=status.HTTP_200_OK):
        response = self.client.put(url, data, format="json")
        self.assertEqual(response.status_code, expected_status_code)
        return response

    def 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)
        return response


class BookmarkHtmlTag:
    def __init__(
        self,
        href: str = "",
        title: str = "",
        description: str = "",
        add_date: str = "",
        last_modified: str = "",
        tags: str = "",
        to_read: bool = False,
        private: bool = True,
    ):
        self.href = href
        self.title = title
        self.description = description
        self.add_date = add_date
        self.last_modified = last_modified
        self.tags = tags
        self.to_read = to_read
        self.private = private


class ImportTestMixin:
    def render_tag(self, tag: BookmarkHtmlTag):
        return f"""
        <DT>
        <A {f'HREF="{tag.href}"' if tag.href else ""}
           {f'ADD_DATE="{tag.add_date}"' if tag.add_date else ""}
           {f'LAST_MODIFIED="{tag.last_modified}"' if tag.last_modified else ""}
           {f'TAGS="{tag.tags}"' if tag.tags else ""}
           TOREAD="{1 if tag.to_read else 0}"
           PRIVATE="{1 if tag.private else 0}">
           {tag.title if tag.title else ""}
        </A>
        {f"<DD>{tag.description}" if tag.description else ""}
        """

    def render_html(self, tags: list[BookmarkHtmlTag] = None, tags_html: str = ""):
        if tags:
            rendered_tags = [self.render_tag(tag) for tag in tags]
            tags_html = "\n".join(rendered_tags)
        return f"""
        <!DOCTYPE NETSCAPE-Bookmark-file-1>
        <META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8">
        <TITLE>Bookmarks</TITLE>
        <H1>Bookmarks</H1>
        <DL><p>
        {tags_html}
        </DL><p>
        """


_words = [
    "quasi",
    "consequatur",
    "necessitatibus",
    "debitis",
    "quod",
    "vero",
    "qui",
    "commodi",
    "quod",
    "odio",
    "aliquam",
    "veniam",
    "architecto",
    "consequatur",
    "autem",
    "qui",
    "iste",
    "asperiores",
    "soluta",
    "et",
]


def random_sentence(num_words: int = None, including_word: str = ""):
    if num_words is None:
        num_words = random.randint(5, 10)
    selected_words = random.choices(_words, k=num_words)
    if including_word:
        selected_words.append(including_word)
    random.shuffle(selected_words)

    return " ".join(selected_words)


def disable_logging(f):
    def wrapper(*args):
        logging.disable(logging.CRITICAL)
        result = f(*args)
        logging.disable(logging.NOTSET)

        return result

    return wrapper


def collapse_whitespace(text: str):
    text = text.replace("\n", "").replace("\r", "")
    return " ".join(text.split())


================================================
FILE: bookmarks/tests/resources/simple_valid_import_file.html
================================================
<!DOCTYPE NETSCAPE-Bookmark-file-1>

<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8">

<TITLE>Bookmarks</TITLE>

<H1>Bookmarks</H1>

<DL><p>

    <DT><A HREF="https://example.com/1" ADD_DATE="1616337559" PRIVATE="0" TOREAD="0" TAGS="tag1">test title 1</A>
    <DD>test description 1

    <DT><A HREF="https://example.com/2" ADD_DATE="1616337559000" PRIVATE="0" TOREAD="0" TAGS="tag2">test title 2</A>
    <DD>test description 2

    <DT><A HREF="https://example.com/3" ADD_DATE="1616337559000000" PRIVATE="0" TOREAD="0" TAGS="tag3">test title 3</A>
    <DD>test description 3

</DL><p>

================================================
FILE: bookmarks/tests/resources/simple_valid_import_file_with_one_invalid_bookmark.html
================================================
<!DOCTYPE NETSCAPE-Bookmark-file-1>

<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8">

<TITLE>Bookmarks</TITLE>

<H1>Bookmarks</H1>

<DL><p>

    <DT><A HREF="https://example.com/1" ADD_DATE="invaliddate" PRIVATE="0" TOREAD="0" TAGS="tag1">test title 1</A>
    <DD>test description 1

    <DT><A HREF="https://example.com/2" ADD_DATE="1616337559" PRIVATE="0" TOREAD="0" TAGS="tag2">test title 2</A>
    <DD>test description 2

    <DT><A HREF="https://example.com/3" ADD_DATE="1616337559" PRIVATE="0" TOREAD="0" TAGS="tag3">test title 3</A>
    <DD>test description 3

</DL><p>

================================================
FILE: bookmarks/tests/test_app_options.py
================================================
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("bookmarks.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"],
        )


================================================
FILE: bookmarks/tests/test_assets_service.py
================================================
import datetime
import gzip
import os
from datetime import timedelta
from pathlib import Path
from unittest import mock

from django.core.files.uploadedfile import SimpleUploadedFile
from django.test import TestCase, override_settings
from django.utils import timezone

from bookmarks.models import BookmarkAsset
from bookmarks.services import assets
from bookmarks.tests.helpers import BookmarkFactoryMixin, disable_logging


class AssetServiceTestCase(TestCase, BookmarkFactoryMixin):
    def setUp(self) -> None:
        self.setup_temp_assets_dir()
        self.get_or_create_test_user()

        self.html_content = "<html><body><h1>Hello, World!</h1></body></html>"
        self.pdf_content = b"%PDF-1.4 test pdf content"

        self.mock_singlefile_create_snapshot_patcher = mock.patch(
            "bookmarks.services.singlefile.create_snapshot",
        )
        self.mock_singlefile_create_snapshot = (
            self.mock_singlefile_create_snapshot_patcher.start()
        )
        self.mock_singlefile_create_snapshot.side_effect = lambda url, filepath: (
            Path(filepath).write_text(self.html_content)
        )

        # Mock detect_content_type to return text/html by default
        self.mock_detect_content_type_patcher = mock.patch(
            "bookmarks.services.assets.detect_content_type",
        )
        self.mock_detect_content_type = self.mock_detect_content_type_patcher.start()
        self.mock_detect_content_type.return_value = "text/html"

        # Mock is_pdf_content_type to return False by default
        self.mock_is_pdf_content_type_patcher = mock.patch(
            "bookmarks.services.assets.is_pdf_content_type",
        )
        self.mock_is_pdf_content_type = self.mock_is_pdf_content_type_patcher.start()
        self.mock_is_pdf_content_type.return_value = False

    def tearDown(self) -> None:
        self.mock_singlefile_create_snapshot_patcher.stop()
        self.mock_detect_content_type_patcher.stop()
        self.mock_is_pdf_content_type_patcher.stop()

    def get_saved_snapshot_file(self):
        # look up first file in the asset folder
        files = os.listdir(self.assets_dir)
        if files:
            return files[0]

    def create_mock_pdf_response(self, content=None, content_length=None):
        if content is None:
            content = self.pdf_content
        mock_response = mock.Mock()
        mock_response.status_code = 200
        mock_response.headers = {"Content-Type": "application/pdf"}
        if content_length is not None:
            mock_response.headers["Content-Length"] = str(content_length)
        mock_response.iter_content = mock.Mock(return_value=[content])
        mock_response.raise_for_status = mock.Mock()
        mock_response.__enter__ = mock.Mock(return_value=mock_response)
        mock_response.__exit__ = mock.Mock(return_value=False)
        return mock_response

    def test_create_snapshot_asset(self):
        bookmark = self.setup_bookmark()

        asset = assets.create_snapshot_asset(bookmark)

        self.assertIsNotNone(asset)
        self.assertEqual(asset.bookmark, bookmark)
        self.assertEqual(asset.asset_type, BookmarkAsset.TYPE_SNAPSHOT)
        self.assertEqual(asset.content_type, "")
        self.assertEqual(asset.display_name, "New snapshot")
        self.assertEqual(asset.status, BookmarkAsset.STATUS_PENDING)

        # asset is not saved to the database
        self.assertIsNone(asset.id)

    def test_create_snapshot(self):
        initial_modified = timezone.datetime(2025, 1, 1, 0, 0, 0, tzinfo=datetime.UTC)
        bookmark = self.setup_bookmark(
            url="https://example.com", modified=initial_modified
        )
        asset = assets.create_snapshot_asset(bookmark)
        asset.save()
        asset.date_created = timezone.datetime(
            2023, 8, 11, 21, 45, 11, tzinfo=datetime.UTC
        )

        assets.create_snapshot(asset)

        expected_temp_filename = "snapshot_2023-08-11_214511_https___example.com.tmp"
        expected_temp_filepath = os.path.join(self.assets_dir, expected_temp_filename)
        expected_filename = "snapshot_2023-08-11_214511_https___example.com.html.gz"
        expected_filepath = os.path.join(self.assets_dir, expected_filename)

        # should call singlefile.create_snapshot with the correct arguments
        self.mock_singlefile_create_snapshot.assert_called_once_with(
            "https://example.com",
            expected_temp_filepath,
        )

        # should create gzip file in asset folder
        self.assertTrue(os.path.exists(expected_filepath))

        # gzip file should contain the correct content
        with gzip.open(expected_filepath, "rb") as gz_file:
            self.assertEqual(gz_file.read().decode(), self.html_content)

        # should remove temporary file
        self.assertFalse(os.path.exists(expected_temp_filepath))

        # should update asset status and file
        asset.refresh_from_db()
        self.assertEqual(asset.status, BookmarkAsset.STATUS_COMPLETE)
        self.assertEqual(asset.content_type, BookmarkAsset.CONTENT_TYPE_HTML)
        self.assertIn("HTML snapshot from", asset.display_name)
        self.assertEqual(asset.file, expected_filename)
        self.assertTrue(asset.gzip)

        # should update bookmark modified date
        bookmark.refresh_from_db()

    def test_create_snapshot_failure(self):
        bookmark = self.setup_bookmark(url="https://example.com")
        asset = assets.create_snapshot_asset(bookmark)
        asset.save()

        self.mock_singlefile_create_snapshot.side_effect = RuntimeError(
            "Snapshot failed"
        )

        with self.assertRaises(RuntimeError):
            assets.create_snapshot(asset)

        asset.refresh_from_db()
        self.assertEqual(asset.status, BookmarkAsset.STATUS_FAILURE)

    def test_create_snapshot_truncates_asset_file_name(self):
        # Create a bookmark with a very long URL
        long_url = "http://" + "a" * 300 + ".com"
        bookmark = self.setup_bookmark(url=long_url)

        asset = assets.create_snapshot_asset(bookmark)
        asset.save()
        assets.create_snapshot(asset)

        saved_file = self.get_saved_snapshot_file()

        self.assertEqual(192, len(saved_file))
        self.assertTrue(saved_file.startswith("snapshot_"))
        self.assertTrue(saved_file.endswith("aaaa.html.gz"))

    def test_create_pdf_snapshot(self):
        bookmark = self.setup_bookmark(url="https://example.com/doc.pdf")
        asset = assets.create_snapshot_asset(bookmark)
        asset.save()
        asset.date_created = timezone.datetime(
            2023, 8, 11, 21, 45, 11, tzinfo=datetime.UTC
        )

        self.mock_detect_content_type.return_value = "application/pdf"
        self.mock_is_pdf_content_type.return_value = True

        with mock.patch("bookmarks.services.assets.requests.get") as mock_get:
            mock_get.return_value = self.create_mock_pdf_response()
            assets.create_snapshot(asset)

        expected_filename = (
            "snapshot_2023-08-11_214511_https___example.com_doc.pdf.pdf.gz"
        )
        expected_filepath = os.path.join(self.assets_dir, expected_filename)

        # should create gzip file in asset folder
        self.assertTrue(os.path.exists(expected_filepath))

        # gzip file should contain the correct content
        with gzip.open(expected_filepath, "rb") as gz_file:
            self.assertEqual(gz_file.read(), self.pdf_content)

        # should update asset status and file
        asset.refresh_from_db()
        self.assertEqual(asset.status, BookmarkAsset.STATUS_COMPLETE)
        self.assertEqual(asset.file, expected_filename)
        self.assertEqual(asset.content_type, BookmarkAsset.CONTENT_TYPE_PDF)
        self.assertIn("PDF download from", asset.display_name)
        self.assertTrue(asset.gzip)

        # should update bookmark
        bookmark.refresh_from_db()
        self.assertEqual(bookmark.latest_snapshot, asset)

    def test_create_snapshot_falls_back_to_singlefile_when_detection_fails(self):
        bookmark = self.setup_bookmark(url="https://example.com")
        asset = assets.create_snapshot_asset(bookmark)
        asset.save()

        self.mock_detect_content_type.return_value = None  # Detection failed

        assets.create_snapshot(asset)

        asset.refresh_from_db()
        self.assertEqual(asset.status, BookmarkAsset.STATUS_COMPLETE)
        self.assertEqual(asset.content_type, BookmarkAsset.CONTENT_TYPE_HTML)
        self.mock_singlefile_create_snapshot.assert_called()

    @override_settings(LD_SNAPSHOT_PDF_MAX_SIZE=100)
    def test_create_pdf_snapshot_fails_when_content_length_exceeds_limit(self):
        bookmark = self.setup_bookmark(url="https://example.com/doc.pdf")
        asset = assets.create_snapshot_asset(bookmark)
        asset.save()

        self.mock_detect_content_type.return_value = "application/pdf"
        self.mock_is_pdf_content_type.return_value = True

        with mock.patch("bookmarks.services.assets.requests.get") as mock_get:
            mock_get.return_value = self.create_mock_pdf_response(
                content_length=1000  # Exceeds 100 byte limit
            )

            with self.assertRaises(assets.PdfTooLargeError):
                assets.create_snapshot(asset)

        asset.refresh_from_db()
        self.assertEqual(asset.status, BookmarkAsset.STATUS_FAILURE)

    @override_settings(LD_SNAPSHOT_PDF_MAX_SIZE=100)
    def test_create_pdf_snapshot_fails_when_download_exceeds_limit(self):
        bookmark = self.setup_bookmark(url="https://example.com/doc.pdf")
        asset = assets.create_snapshot_asset(bookmark)
        asset.save()

        large_content = b"x" * 150  # Exceeds 100 byte limit

        self.mock_detect_content_type.return_value = "application/pdf"
        self.mock_is_pdf_content_type.return_value = True

        with mock.patch("bookmarks.services.assets.requests.get") as mock_get:
            # Response without Content-Length header, will fail during streaming
            mock_get.return_value = self.create_mock_pdf_response(content=large_content)

            with self.assertRaises(assets.PdfTooLargeError):
                assets.create_snapshot(asset)

        asset.refresh_from_db()
        self.assertEqual(asset.status, BookmarkAsset.STATUS_FAILURE)

    def test_create_pdf_snapshot_failure(self):
        bookmark = self.setup_bookmark(url="https://example.com/doc.pdf")
        asset = assets.create_snapshot_asset(bookmark)
        asset.save()

        self.mock_detect_content_type.return_value = "application/pdf"
        self.mock_is_pdf_content_type.return_value = True

        with mock.patch("bookmarks.services.assets.requests.get") as mock_get:
            import requests

            mock_get.side_effect = requests.RequestException("Download failed")

            with self.assertRaises(requests.RequestException):
                assets.create_snapshot(asset)

        asset.refresh_from_db()
        self.assertEqual(asset.status, BookmarkAsset.STATUS_FAILURE)

    def test_upload_snapshot(self):
        initial_modified = timezone.datetime(2025, 1, 1, 0, 0, 0, tzinfo=datetime.UTC)
        bookmark = self.setup_bookmark(
            url="https://example.com", modified=initial_modified
        )
        asset = assets.upload_snapshot(bookmark, self.html_content.encode())

        # should create gzip file in asset folder
        saved_file_name = self.get_saved_snapshot_file()
        self.assertIsNotNone(saved_file_name)

        # verify file name
        self.assertTrue(saved_file_name.startswith("snapshot_"))
        self.assertTrue(saved_file_name.endswith("_https___example.com.html.gz"))

        # gzip file should contain the correct content
        with gzip.open(os.path.join(self.assets_dir, saved_file_name), "rb") as gz_file:
            self.assertEqual(gz_file.read().decode(), self.html_content)

        # should create asset
        self.assertIsNotNone(asset.id)
        self.assertEqual(asset.bookmark, bookmark)
        self.assertEqual(asset.asset_type, BookmarkAsset.TYPE_SNAPSHOT)
        self.assertEqual(asset.content_type, BookmarkAsset.CONTENT_TYPE_HTML)
        self.assertIn("HTML snapshot from", asset.display_name)
        self.assertEqual(asset.status, BookmarkAsset.STATUS_COMPLETE)
        self.assertEqual(asset.file, saved_file_name)
        self.assertTrue(asset.gzip)

        # should update bookmark modified date
        bookmark.refresh_from_db()
        self.assertGreater(bookmark.date_modified, initial_modified)

    def test_upload_snapshot_failure(self):
        bookmark = self.setup_bookmark(url="https://example.com")

        # make gzip.open raise an exception
        with mock.patch("gzip.open") as mock_gzip_open:
            mock_gzip_open.side_effect = OSError("File operation failed")

            with self.assertRaises(OSError):
                assets.upload_snapshot(bookmark, b"invalid content")

        # asset is not saved to the database
        self.assertIsNone(BookmarkAsset.objects.first())

    def test_upload_snapshot_truncates_asset_file_name(self):
        # Create a bookmark with a very long URL
        long_url = "http://" + "a" * 300 + ".com"
        bookmark = self.setup_bookmark(url=long_url)

        assets.upload_snapshot(bookmark, self.html_content.encode())

        saved_file = self.get_saved_snapshot_file()

        self.assertEqual(192, len(saved_file))
        self.assertTrue(saved_file.startswith("snapshot_"))
        self.assertTrue(saved_file.endswith("aaaa.html.gz"))

    @disable_logging
    def test_upload_asset(self):
        initial_modified = timezone.datetime(2025, 1, 1, 0, 0, 0, tzinfo=datetime.UTC)
        bookmark = self.setup_bookmark(modified=initial_modified)
        file_content = b"test content"
        upload_file = SimpleUploadedFile(
            "test_file.txt", file_content, content_type="text/plain"
        )

        asset = assets.upload_asset(bookmark, upload_file)

        # should create file in asset folder
        saved_file_name = self.get_saved_snapshot_file()
        self.assertIsNotNone(upload_file)

        # verify file name
        self.assertTrue(saved_file_name.startswith("upload_"))
        self.assertTrue(saved_file_name.endswith("_test_file.txt.gz"))

        # file should contain the correct content
        self.assertEqual(self.read_asset_file(asset), file_content)

        # should create asset
        self.assertIsNotNone(asset.id)
        self.assertEqual(asset.bookmark, bookmark)
        self.assertEqual(asset.asset_type, BookmarkAsset.TYPE_UPLOAD)
        self.assertEqual(asset.content_type, upload_file.content_type)
        self.assertEqual(asset.display_name, upload_file.name)
        self.assertEqual(asset.status, BookmarkAsset.STATUS_COMPLETE)
        self.assertEqual(asset.file, saved_file_name)
        self.assertEqual(asset.file_size, self.get_asset_filesize(asset))
        self.assertTrue(asset.gzip)

        # should update bookmark modified date
        bookmark.refresh_from_db()
        self.assertGreater(bookmark.date_modified, initial_modified)

    @disable_logging
    def test_upload_gzip_asset(self):
        initial_modified = timezone.datetime(2025, 1, 1, 0, 0, 0, tzinfo=datetime.UTC)
        bookmark = self.setup_bookmark(modified=initial_modified)
        file_content = gzip.compress(b"<html>test content</html>")
        upload_file = SimpleUploadedFile(
            "test_file.html.gz", file_content, content_type="application/gzip"
        )

        asset = assets.upload_asset(bookmark, upload_file)

        # should create file in asset folder
        saved_file_name = self.get_saved_snapshot_file()
        self.assertIsNotNone(upload_file)

        # verify file name
        self.assertTrue(saved_file_name.startswith("upload_"))
        self.assertTrue(saved_file_name.endswith("_test_file.html.gz"))

        # file should contain the correct content
        self.assertEqual(self.read_asset_file(asset), file_content)

        # should create asset
        self.assertIsNotNone(asset.id)
        self.assertEqual(asset.bookmark, bookmark)
        self.assertEqual(asset.asset_type, BookmarkAsset.TYPE_UPLOAD)
        self.assertEqual(asset.content_type, "application/gzip")
        self.assertEqual(asset.display_name, upload_file.name)
        self.assertEqual(asset.status, BookmarkAsset.STATUS_COMPLETE)
        self.assertEqual(asset.file, saved_file_name)
        self.assertEqual(asset.file_size, len(file_content))
        self.assertFalse(asset.gzip)

        # should update bookmark modified date
        bookmark.refresh_from_db()
        self.assertGreater(bookmark.date_modified, initial_modified)

    @disable_logging
    def test_upload_asset_truncates_asset_file_name(self):
        # Create a bookmark with a very long URL
        long_file_name = "a" * 300 + ".txt"
        bookmark = self.setup_bookmark()

        file_content = b"test content"
        upload_file = SimpleUploadedFile(
            long_file_name, file_content, content_type="text/plain"
        )

        assets.upload_asset(bookmark, upload_file)

        saved_file = self.get_saved_snapshot_file()

        self.assertEqual(192, len(saved_file))
        self.assertTrue(saved_file.startswith("upload_"))
        self.assertTrue(saved_file.endswith("aaaa.txt.gz"))

    @disable_logging
    def test_upload_asset_failure(self):
        bookmark = self.setup_bookmark()
        upload_file = SimpleUploadedFile("test_file.txt", b"test content")

        # make open raise an exception
        with mock.patch("builtins.open") as mock_open:
            mock_open.side_effect = OSError("File operation failed")

            with self.assertRaises(OSError):
                assets.upload_asset(bookmark, upload_file)

        # asset is not saved to the database
        self.assertIsNone(BookmarkAsset.objects.first())

    def test_create_snapshot_updates_bookmark_latest_snapshot(self):
        bookmark = self.setup_bookmark(url="https://example.com")
        first_asset = assets.create_snapshot_asset(bookmark)
        first_asset.save()

        assets.create_snapshot(first_asset)
        bookmark.refresh_from_db()

        self.assertEqual(bookmark.latest_snapshot, first_asset)

        second_asset = assets.create_snapshot_asset(bookmark)
        second_asset.save()

        assets.create_snapshot(second_asset)
        bookmark.refresh_from_db()

        self.assertEqual(bookmark.latest_snapshot, second_asset)

    def test_upload_snapshot_updates_bookmark_latest_snapshot(self):
        bookmark = self.setup_bookmark(url="https://example.com")

        first_asset = assets.upload_snapshot(bookmark, self.html_content.encode())

        bookmark.refresh_from_db()
        self.assertEqual(bookmark.latest_snapshot, first_asset)

        second_asset = assets.upload_snapshot(bookmark, self.html_content.encode())

        bookmark.refresh_from_db()
        self.assertEqual(bookmark.latest_snapshot, second_asset)
        self.assertNotEqual(bookmark.latest_snapshot, first_asset)

    def test_create_snapshot_failure_does_not_update_latest_snapshot(self):
        # Create a bookmark with an existing latest_snapshot
        bookmark = self.setup_bookmark(url="https://example.com")
        initial_snapshot = assets.upload_snapshot(bookmark, self.html_content.encode())
        bookmark.refresh_from_db()
        self.assertEqual(bookmark.latest_snapshot, initial_snapshot)

        # Create a new snapshot asset that will fail
        failing_asset = assets.create_snapshot_asset(bookmark)
        failing_asset.save()

        # Make the snapshot creation fail
        self.mock_singlefile_create_snapshot.side_effect = RuntimeError(
            "Snapshot creation failed"
        )

        # Attempt to create a snapshot (which will fail)
        with self.assertRaises(RuntimeError):
            assets.create_snapshot(failing_asset)

        # Verify that the bookmark's latest_snapshot is still the initial snapshot
        bookmark.refresh_from_db()
        self.assertEqual(bookmark.latest_snapshot, initial_snapshot)

    def test_upload_snapshot_failure_does_not_update_latest_snapshot(self):
        # Create a bookmark with an existing latest_snapshot
        bookmark = self.setup_bookmark(url="https://example.com")
        initial_snapshot = assets.upload_snapshot(bookmark, self.html_content.encode())
        bookmark.refresh_from_db()
        self.assertEqual(bookmark.latest_snapshot, initial_snapshot)

        # Make the gzip.open function fail
        with mock.patch("gzip.open") as mock_gzip_open:
            mock_gzip_open.side_effect = OSError("Upload failed")

            # Attempt to upload a snapshot (which will fail)
            with self.assertRaises(OSError):
                assets.upload_snapshot(bookmark, b"New content")

        # Verify that the bookmark's latest_snapshot is still the initial snapshot
        bookmark.refresh_from_db()
        self.assertEqual(bookmark.latest_snapshot, initial_snapshot)

    def test_remove_latest_snapshot_updates_bookmark(self):
        # Create a bookmark with multiple snapshots
        bookmark = self.setup_bookmark()

        # Create base time (1 hour ago)
        base_time = timezone.now() - timedelta(hours=1)

        # Create three snapshots with explicitly different dates
        old_asset = self.setup_asset(
            bookmark=bookmark,
            asset_type=BookmarkAsset.TYPE_SNAPSHOT,
            status=BookmarkAsset.STATUS_COMPLETE,
            file="old_snapshot.html.gz",
            date_created=base_time,
        )
        self.setup_asset_file(old_asset)

        middle_asset = self.setup_asset(
            bookmark=bookmark,
            asset_type=BookmarkAsset.TYPE_SNAPSHOT,
            status=BookmarkAsset.STATUS_COMPLETE,
            file="middle_snapshot.html.gz",
            date_created=base_time + timedelta(minutes=30),
        )
        self.setup_asset_file(middle_asset)

        latest_asset = self.setup_asset(
            bookmark=bookmark,
            asset_type=BookmarkAsset.TYPE_SNAPSHOT,
            status=BookmarkAsset.STATUS_COMPLETE,
            file="latest_snapshot.html.gz",
            date_created=base_time + timedelta(minutes=60),
        )
        self.setup_asset_file(latest_asset)

        # Set the latest asset as the bookmark's latest_snapshot
        bookmark.latest_snapshot = latest_asset
        bookmark.save()

        # Delete the latest snapshot
        assets.remove_asset(latest_asset)
        bookmark.refresh_from_db()

        # Verify that middle_asset is now the latest_snapshot
        self.assertEqual(bookmark.latest_snapshot, middle_asset)

        # Delete the middle snapshot
        assets.remove_asset(middle_asset)
        bookmark.refresh_from_db()

        # Verify that old_asset is now the latest_snapshot
        self.assertEqual(bookmark.latest_snapshot, old_asset)

        # Delete the last snapshot
        assets.remove_asset(old_asset)
        bookmark.refresh_from_db()

        # Verify that latest_snapshot is now None
        self.assertIsNone(bookmark.latest_snapshot)

    def test_remove_non_latest_snapshot_does_not_affect_bookmark(self):
        # Create a bookmark with multiple snapshots
        bookmark = self.setup_bookmark()

        # Create base time (1 hour ago)
        base_time = timezone.now() - timedelta(hours=1)

        # Create two snapshots with explicitly different dates
        old_asset = self.setup_asset(
            bookmark=bookmark,
            asset_type=BookmarkAsset.TYPE_SNAPSHOT,
            status=BookmarkAsset.STATUS_COMPLETE,
            file="old_snapshot.html.gz",
            date_created=base_time,
        )
        self.setup_asset_file(old_asset)

        latest_asset = self.setup_asset(
            bookmark=bookmark,
            asset_type=BookmarkAsset.TYPE_SNAPSHOT,
            status=BookmarkAsset.STATUS_COMPLETE,
            file="latest_snapshot.html.gz",
            date_created=base_time + timedelta(minutes=30),
        )
        self.setup_asset_file(latest_asset)

        # Set the latest asset as the bookmark's latest_snapshot
        bookmark.latest_snapshot = latest_asset
        bookmark.save()

        # Delete the old snapshot (not the latest)
        assets.remove_asset(old_asset)
        bookmark.refresh_from_db()

        # Verify that latest_snapshot hasn't changed
        self.assertEqual(bookmark.latest_snapshot, latest_asset)

    @disable_logging
    def test_remove_asset(self):
        initial_modified = timezone.datetime(2025, 1, 1, 0, 0, 0, tzinfo=datetime.UTC)
        bookmark = self.setup_bookmark(modified=initial_modified)
        file_content = b"test content for removal"
        upload_file = SimpleUploadedFile(
            "test_remove_file.txt", file_content, content_type="text/plain"
        )

        asset = assets.upload_asset(bookmark, upload_file)
        asset_filepath = os.path.join(self.assets_dir, asset.file)

        # Verify asset and file exist
        self.assertTrue(BookmarkAsset.objects.filter(id=asset.id).exists())
        self.assertTrue(os.path.exists(asset_filepath))

        bookmark.date_modified = initial_modified
        bookmark.save()

        # Remove the asset
        assets.remove_asset(asset)

        # Verify asset is removed from DB
        self.assertFalse(BookmarkAsset.objects.filter(id=asset.id).exists())
        # Verify file is removed from disk
        self.assertFalse(os.path.exists(asset_filepath))

        # Verify bookmark modified date is updated
        bookmark.refresh_from_db()
        self.assertGreater(bookmark.date_modified, initial_modified)


================================================
FILE: bookmarks/tests/test_auth_api.py
================================================
from django.urls import reverse
from rest_framework import status

from bookmarks.tests.helpers import BookmarkFactoryMixin, LinkdingApiTestCase


class AuthApiTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
    def authenticate(self, keyword):
        self.api_token = self.setup_api_token()
        self.client.credentials(HTTP_AUTHORIZATION=f"{keyword} {self.api_token.key}")

    def test_auth_with_token_keyword(self):
        self.authenticate("Token")

        url = reverse("linkding:user-profile")
        self.get(url, expected_status_code=status.HTTP_200_OK)

    def test_auth_with_bearer_keyword(self):
        self.authenticate("Bearer")

        url = reverse("linkding:user-profile")
        self.get(url, expected_status_code=status.HTTP_200_OK)

    def test_auth_with_unknown_keyword(self):
        self.authenticate("Key")

        url = reverse("linkding:user-profile")
        self.get(url, expected_status_code=status.HTTP_401_UNAUTHORIZED)


================================================
FILE: bookmarks/tests/test_auth_proxy_support.py
================================================
from unittest.mock import PropertyMock, patch

from django.test import TestCase, modify_settings
from django.urls import reverse

from bookmarks.middlewares import CustomRemoteUserMiddleware
from bookmarks.models import User


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("linkding: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("linkding: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("linkding:bookmarks.index"), **headers, follow=True
        )

        self.assertRedirects(response, "/login/?next=%2Fbookmarks")


================================================
FILE: bookmarks/tests/test_auto_tagging.py
================================================
from django.test import TestCase

from bookmarks.services import auto_tagging


class AutoTaggingTestCase(TestCase):
    def test_auto_tag_by_domain(self):
        script = """
            example.com example
            test.com test
        """
        url = "https://example.com/"

        tags = auto_tagging.get_tags(script, url)

        self.assertEqual(tags, {"example"})

    def test_auto_tag_by_domain_handles_invalid_urls(self):
        script = """
            example.com example
            test.com test
        """

        url = "https://"
        tags = auto_tagging.get_tags(script, url)
        self.assertEqual(tags, set([]))

        url = "example.com"
        tags = auto_tagging.get_tags(script, url)
        self.assertEqual(tags, set([]))

    def test_auto_tag_by_domain_works_with_port(self):
        script = """
            example.com example
            test.com test
        """
        url = "https://example.com:8080/"

        tags = auto_tagging.get_tags(script, url)

        self.assertEqual(tags, {"example"})

    def test_auto_tag_by_domain_ignores_case(self):
        script = """
            EXAMPLE.com example
        """
        url = "https://example.com/"

        tags = auto_tagging.get_tags(script, url)

        self.assertEqual(tags, {"example"})

    def test_auto_tag_by_domain_should_add_all_tags(self):
        script = """
            example.com one two three
        """
        url = "https://example.com/"

        tags = auto_tagging.get_tags(script, url)

        self.assertEqual(tags, {"one", "two", "three"})

    def test_auto_tag_by_domain_work_with_idn_domains(self):
        script = """
            रजिस्ट्री.भारत tag1
        """
        url = "https://www.xn--81bg3cc2b2bk5hb.xn--h2brj9c/"

        tags = auto_tagging.get_tags(script, url)

        self.assertEqual(tags, {"tag1"})

        script = """
            xn--81bg3cc2b2bk5hb.xn--h2brj9c tag1
        """
        url = "https://www.रजिस्ट्री.भारत/"

        tags = auto_tagging.get_tags(script, url)

        self.assertEqual(tags, {"tag1"})

    def test_auto_tag_by_domain_and_path(self):
        script = """
            example.com/one one
            example.com/two two
            test.com test
        """
        url = "https://example.com/one/"

        tags = auto_tagging.get_tags(script, url)

        self.assertEqual(tags, {"one"})

    def test_auto_tag_by_domain_and_path_ignores_case(self):
        script = """
            example.com/One one
        """
        url = "https://example.com/one/"

        tags = auto_tagging.get_tags(script, url)

        self.assertEqual(tags, {"one"})

    def test_auto_tag_by_domain_and_path_matches_path_ltr(self):
        script = """
            example.com/one one
            example.com/two two
            test.com test
        """
        url = "https://example.com/one/two"

        tags = auto_tagging.get_tags(script, url)

        self.assertEqual(tags, {"one"})

    def test_auto_tag_by_domain_ignores_domain_in_path(self):
        script = """
            example.com example
        """
        url = "https://test.com/example.com"

        tags = auto_tagging.get_tags(script, url)

        self.assertEqual(tags, set([]))

    def test_auto_tag_by_domain_includes_subdomains(self):
        script = """
            example.com example
            test.example.com test
            some.example.com some
        """
        url = "https://test.example.com/"

        tags = auto_tagging.get_tags(script, url)

        self.assertEqual(tags, {"example", "test"})

    def test_auto_tag_by_domain_matches_domain_rtl(self):
        script = """
            example.com example
        """
        url = "https://example.com.bad-website.com/"

        tags = auto_tagging.get_tags(script, url)

        self.assertEqual(tags, set([]))

    def test_auto_tag_by_domain_ignores_schema(self):
        script = """
            https://example.com/ https
            http://example.com/ http
        """
        url = "http://example.com/"

        tags = auto_tagging.get_tags(script, url)

        self.assertEqual(tags, {"https", "http"})

    def test_auto_tag_by_domain_ignores_lines_with_no_tags(self):
        script = """
            example.com
        """
        url = "https://example.com/"

        tags = auto_tagging.get_tags(script, url)

        self.assertEqual(tags, set([]))

    def test_auto_tag_by_domain_path_and_qs(self):
        script = """
            example.com/page?a=b tag1     # true, matches a=b
            example.com/page?a=c&c=d tag2 # true, matches both a=c and c=d
            example.com/page?c=d&l=p tag3 # false, l=p doesn't exists
            example.com/page?a=bb tag4    # false bb != b
            example.com/page?a=b&a=c tag5 # true, matches both a=b and a=c
            example.com/page?a=B tag6     # true, matches a=b because case insensitive
            example.com/page?A=b tag7     # true, matches a=b because case insensitive
        """
        url = "https://example.com/page/some?z=x&a=b&v=b&c=d&o=p&a=c"

        tags = auto_tagging.get_tags(script, url)

        self.assertEqual(tags, {"tag1", "tag2", "tag5", "tag6", "tag7"})

    def test_auto_tag_by_domain_path_and_qs_with_empty_value(self):
        script = """
            example.com/page?a= tag1
            example.com/page?b= tag2
        """
        url = "https://example.com/page/some?a=value"

        tags = auto_tagging.get_tags(script, url)

        self.assertEqual(tags, {"tag1"})

    def test_auto_tag_by_domain_path_and_qs_works_with_encoded_url(self):
        script = """
            example.com/page?a=йцу tag1
            example.com/page?a=%D0%B9%D1%86%D1%83 tag2
        """
        url = "https://example.com/page?a=%D0%B9%D1%86%D1%83"

        tags = auto_tagging.get_tags(script, url)

        self.assertEqual(tags, {"tag1", "tag2"})

    def test_auto_tag_with_url_fragment(self):
        script = """
            example.com/#/section/1 section1
            example.com/#/section/2 section2
        """
        url = "https://example.com/#/section/1"

        tags = auto_tagging.get_tags(script, url)

        self.assertEqual(tags, {"section1"})

    def test_auto_tag_with_url_fragment_partial_match(self):
        script = """
            example.com/#/section section
        """
        url = "https://example.com/#/section/1"

        tags = auto_tagging.get_tags(script, url)

        self.assertEqual(tags, {"section"})

    def test_auto_tag_with_url_fragment_ignores_case(self):
        script = """
            example.com/#SECTION section
        """
        url = "https://example.com/#section"

        tags = auto_tagging.get_tags(script, url)

        self.assertEqual(tags, {"section"})

    def test_auto_tag_with_url_fragment_and_comment(self):
        script = """
            example.com/#section1 section1 #This is a comment
        """
        url = "https://example.com/#section1"

        tags = auto_tagging.get_tags(script, url)

        self.assertEqual(tags, {"section1"})


================================================
FILE: bookmarks/tests/test_bookmark_action_view.py
================================================
from unittest.mock import patch

from django.contrib.auth.models import User
from django.core.files.uploadedfile import SimpleUploadedFile
from django.forms import model_to_dict
from django.http import HttpResponse
from django.test import TestCase, override_settings
from django.urls import reverse

from bookmarks.models import Bookmark, BookmarkAsset
from bookmarks.services import assets, tasks
from bookmarks.tests.helpers import (
    BookmarkFactoryMixin,
    BookmarkListTestMixin,
    TagCloudTestMixin,
)


class BookmarkActionViewTestCase(
    TestCase, BookmarkFactoryMixin, BookmarkListTestMixin, TagCloudTestMixin
):
    def setUp(self) -> None:
        user = self.get_or_create_test_user()
        self.client.force_login(user)

    def assertBookmarksAreUnmodified(self, bookmarks: [Bookmark]):
        self.assertEqual(len(bookmarks), Bookmark.objects.count())

        for bookmark in bookmarks:
            self.assertEqual(
                model_to_dict(bookmark),
                model_to_dict(Bookmark.objects.get(id=bookmark.id)),
            )

    def test_archive_should_archive_bookmark(self):
        bookmark = self.setup_bookmark()

        self.client.post(
            reverse("linkding:bookmarks.index.action"),
            {
                "archive": [bookmark.id],
            },
        )

        bookmark.refresh_from_db()

        self.assertTrue(bookmark.is_archived)

    def test_can_only_archive_own_bookmarks(self):
        other_user = User.objects.create_user(
            "otheruser", "otheruser@example.com", "password123"
        )
        bookmark = self.setup_bookmark(user=other_user)

        response = self.client.post(
            reverse("linkding:bookmarks.index.action"),
            {
                "archive": [bookmark.id],
            },
        )

        bookmark.refresh_from_db()

        self.assertEqual(response.status_code, 404)
        self.assertFalse(bookmark.is_archived)

    def test_unarchive_should_unarchive_bookmark(self):
        bookmark = self.setup_bookmark(is_archived=True)

        self.client.post(
            reverse("linkding:bookmarks.index.action"),
            {
                "unarchive": [bookmark.id],
            },
        )
        bookmark.refresh_from_db()

        self.assertFalse(bookmark.is_archived)

    def test_unarchive_can_only_archive_own_bookmarks(self):
        other_user = User.objects.create_user(
            "otheruser", "otheruser@example.com", "password123"
        )
        bookmark = self.setup_bookmark(is_archived=True, user=other_user)

        response = self.client.post(
            reverse("linkding:bookmarks.index.action"),
            {
                "unarchive": [bookmark.id],
            },
        )
        bookmark.refresh_from_db()

        self.assertEqual(response.status_code, 404)
        self.assertTrue(bookmark.is_archived)

    def test_delete_should_delete_bookmark(self):
        bookmark = self.setup_bookmark()

        self.client.post(
            reverse("linkding:bookmarks.index.action"),
            {
                "remove": [bookmark.id],
            },
        )

        self.assertEqual(Bookmark.objects.count(), 0)

    def test_delete_can_only_delete_own_bookmarks(self):
        other_user = User.objects.create_user(
            "otheruser", "otheruser@example.com", "password123"
        )
        bookmark = self.setup_bookmark(user=other_user)

        response = self.client.post(
            reverse("linkding:bookmarks.index.action"),
            {
                "remove": [bookmark.id],
            },
        )
        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("linkding:bookmarks.index.action"),
            {
                "mark_as_read": [bookmark.id],
            },
        )
        bookmark.refresh_from_db()

        self.assertFalse(bookmark.unread)

    def test_unshare_should_unshare_bookmark(self):
        bookmark = self.setup_bookmark(shared=True)

        self.client.post(
            reverse("linkding:bookmarks.index.action"),
            {
                "unshare": [bookmark.id],
            },
        )

        bookmark.refresh_from_db()

        self.assertFalse(bookmark.shared)

    def test_can_only_unshare_own_bookmarks(self):
        other_user = User.objects.create_user(
            "otheruser", "otheruser@example.com", "password123"
        )
        bookmark = self.setup_bookmark(user=other_user, shared=True)

        response = self.client.post(
            reverse("linkding:bookmarks.index.action"),
            {
                "unshare": [bookmark.id],
            },
        )

        bookmark.refresh_from_db()

        self.assertEqual(response.status_code, 404)
        self.assertTrue(bookmark.shared)

    @override_settings(LD_ENABLE_SNAPSHOTS=True)
    def test_create_html_snapshot(self):
        bookmark = self.setup_bookmark()
        with patch.object(tasks, "_create_html_snapshot_task"):
            self.client.post(
                reverse("linkding:bookmarks.index.action"),
                {
                    "create_html_snapshot": [bookmark.id],
                },
            )
            self.assertEqual(bookmark.bookmarkasset_set.count(), 1)
            asset = bookmark.bookmarkasset_set.first()
            self.assertEqual(asset.asset_type, BookmarkAsset.TYPE_SNAPSHOT)

    @override_settings(LD_ENABLE_SNAPSHOTS=True)
    def test_can_only_create_html_snapshot_for_own_bookmarks(self):
        other_user = self.setup_user()
        bookmark = self.setup_bookmark(user=other_user)
        with patch.object(tasks, "_create_html_snapshot_task"):
            response = self.client.post(
                reverse("linkding:bookmarks.index.action"),
                {
                    "create_html_snapshot": [bookmark.id],
                },
            )
            self.assertEqual(response.status_code, 404)
            self.assertEqual(bookmark.bookmarkasset_set.count(), 0)

    def test_upload_asset(self):
        bookmark = self.setup_bookmark()
        file_content = b"file content"
        upload_file = SimpleUploadedFile("test.txt", file_content)

        with patch.object(assets, "upload_asset") as mock_upload_asset:
            response = self.client.post(
                reverse("linkding:bookmarks.index.action"),
                {"upload_asset": bookmark.id, "upload_asset_file": upload_file},
            )
            self.assertEqual(response.status_code, 302)

            mock_upload_asset.assert_called_once()

            args, _ = mock_upload_asset.call_args
            self.assertEqual(args[0], bookmark)

            upload_file = args[1]
            self.assertEqual(upload_file.name, "test.txt")

    def test_can_only_upload_asset_for_own_bookmarks(self):
        other_user = self.setup_user()
        bookmark = self.setup_bookmark(user=other_user)
        file_content = b"file content"
        upload_file = SimpleUploadedFile("test.txt", file_content)

        with patch.object(assets, "upload_asset") as mock_upload_asset:
            response = self.client.post(
                reverse("linkding:bookmarks.index.action"),
                {"upload_asset": bookmark.id, "upload_asset_file": upload_file},
            )
            self.assertEqual(response.status_code, 404)

            mock_upload_asset.assert_not_called()

    @override_settings(LD_DISABLE_ASSET_UPLOAD=True)
    def test_upload_asset_disabled(self):
        bookmark = self.setup_bookmark()
        file_content = b"file content"
        upload_file = SimpleUploadedFile("test.txt", file_content)

        response = self.client.post(
            reverse("linkding:bookmarks.index.action"),
            {"upload_asset": bookmark.id, "upload_asset_file": upload_file},
        )
        self.assertEqual(response.status_code, 403)

    def test_upload_asset_without_file(self):
        bookmark = self.setup_bookmark()

        response = self.client.post(
            reverse("linkding:bookmarks.index.action"),
            {"upload_asset": bookmark.id},
        )
        self.assertEqual(response.status_code, 400)

    def test_remove_asset(self):
        bookmark = self.setup_bookmark()
        asset = self.setup_asset(bookmark)

        response = self.client.post(
            reverse("linkding:bookmarks.index.action"), {"remove_asset": asset.id}
        )
        self.assertEqual(response.status_code, 302)
        self.assertFalse(BookmarkAsset.objects.filter(id=asset.id).exists())

    def test_can_only_remove_own_asset(self):
        other_user = self.setup_user()
        bookmark = self.setup_bookmark(user=other_user)
        asset = self.setup_asset(bookmark)

        response = self.client.post(
            reverse("linkding:bookmarks.index.action"), {"remove_asset": asset.id}
        )
        self.assertEqual(response.status_code, 404)
        self.assertTrue(BookmarkAsset.objects.filter(id=asset.id).exists())

    def test_update_state(self):
        bookmark = self.setup_bookmark()

        response = self.client.post(
            reverse("linkding:bookmarks.index.action"),
            {
                "update_state": bookmark.id,
                "is_archived": "on",
                "unread": "on",
                "shared": "on",
            },
        )
        self.assertEqual(response.status_code, 302)

        bookmark.refresh_from_db()
        self.assertTrue(bookmark.unread)
        self.assertTrue(bookmark.is_archived)
        self.assertTrue(bookmark.shared)

    def test_can_only_update_own_bookmark_state(self):
        other_user = self.setup_user()
        bookmark = self.setup_bookmark(user=other_user)

        response = self.client.post(
            reverse("linkding:bookmarks.index.action"),
            {
                "update_state": bookmark.id,
                "is_archived": "on",
                "unread": "on",
                "shared": "on",
            },
        )
        self.assertEqual(response.status_code, 404)

        bookmark.refresh_from_db()
        self.assertFalse(bookmark.unread)
        self.assertFalse(bookmark.is_archived)
        self.assertFalse(bookmark.shared)

    def test_bulk_archive(self):
        bookmark1 = self.setup_bookmark()
        bookmark2 = self.setup_bookmark()
        bookmark3 = self.setup_bookmark()

        self.client.post(
            reverse("linkding:bookmarks.index.action"),
            {
                "bulk_action": ["bulk_archive"],
                "bulk_execute": [""],
                "bookmark_id": [
                    str(bookmark1.id),
                    str(bookmark2.id),
                    str(bookmark3.id),
                ],
            },
        )

        self.assertTrue(Bookmark.objects.get(id=bookmark1.id).is_archived)
        self.assertTrue(Bookmark.objects.get(id=bookmark2.id).is_archived)
        self.assertTrue(Bookmark.objects.get(id=bookmark3.id).is_archived)

    def test_can_only_bulk_archive_own_bookmarks(self):
        other_user = User.objects.create_user(
            "otheruser", "otheruser@example.com", "password123"
        )
        bookmark1 = self.setup_bookmark(user=other_user)
        bookmark2 = self.setup_bookmark(user=other_user)
        bookmark3 = self.setup_bookmark(user=other_user)

        self.client.post(
            reverse("linkding:bookmarks.index.action"),
            {
                "bulk_action": ["bulk_archive"],
                "bulk_execute": [""],
                "bookmark_id": [
                    str(bookmark1.id),
                    str(bookmark2.id),
                    str(bookmark3.id),
                ],
            },
        )

        self.assertFalse(Bookmark.objects.get(id=bookmark1.id).is_archived)
        self.assertFalse(Bookmark.objects.get(id=bookmark2.id).is_archived)
        self.assertFalse(Bookmark.objects.get(id=bookmark3.id).is_archived)

    def test_bulk_unarchive(self):
        bookmark1 = self.setup_bookmark(is_archived=True)
        bookmark2 = self.setup_bookmark(is_archived=True)
        bookmark3 = self.setup_bookmark(is_archived=True)

        self.client.post(
            reverse("linkding:bookmarks.archived.action"),
            {
                "bulk_action": ["bulk_unarchive"],
                "bulk_execute": [""],
                "bookmark_id": [
                    str(bookmark1.id),
                    str(bookmark2.id),
                    str(bookmark3.id),
                ],
            },
        )

        self.assertFalse(Bookmark.objects.get(id=bookmark1.id).is_archived)
        self.assertFalse(Bookmark.objects.get(id=bookmark2.id).is_archived)
        self.assertFalse(Bookmark.objects.get(id=bookmark3.id).is_archived)

    def test_can_only_bulk_unarchive_own_bookmarks(self):
        other_user = User.objects.create_user(
            "otheruser", "otheruser@example.com", "password123"
        )
        bookmark1 = self.setup_bookmark(is_archived=True, user=other_user)
        bookmark2 = self.setup_bookmark(is_archived=True, user=other_user)
        bookmark3 = self.setup_bookmark(is_archived=True, user=other_user)

        self.client.post(
            reverse("linkding:bookmarks.archived.action"),
            {
                "bulk_action": ["bulk_unarchive"],
                "bulk_execute": [""],
                "bookmark_id": [
                    str(bookmark1.id),
                    str(bookmark2.id),
                    str(bookmark3.id),
                ],
            },
        )

        self.assertTrue(Bookmark.objects.get(id=bookmark1.id).is_archived)
        self.assertTrue(Bookmark.objects.get(id=bookmark2.id).is_archived)
        self.assertTrue(Bookmark.objects.get(id=bookmark3.id).is_archived)

    def test_bulk_delete(self):
        bookmark1 = self.setup_bookmark()
        bookmark2 = self.setup_bookmark()
        bookmark3 = self.setup_bookmark()

        self.client.post(
            reverse("linkding:bookmarks.index.action"),
            {
                "bulk_action": ["bulk_delete"],
                "bulk_execute": [""],
                "bookmark_id": [
                    str(bookmark1.id),
                    str(bookmark2.id),
                    str(bookmark3.id),
                ],
            },
        )

        self.assertIsNone(Bookmark.objects.filter(id=bookmark1.id).first())
        self.assertIsNone(Bookmark.objects.filter(id=bookmark2.id).first())
        self.assertIsNone(Bookmark.objects.filter(id=bookmark3.id).first())

    def test_can_only_bulk_delete_own_bookmarks(self):
        other_user = User.objects.create_user(
            "otheruser", "otheruser@example.com", "password123"
        )
        bookmark1 = self.setup_bookmark(user=other_user)
        bookmark2 = self.setup_bookmark(user=other_user)
        bookmark3 = self.setup_bookmark(user=other_user)

        self.client.post(
            reverse("linkding:bookmarks.index.action"),
            {
                "bulk_action": ["bulk_delete"],
                "bulk_execute": [""],
                "bookmark_id": [
                    str(bookmark1.id),
                    str(bookmark2.id),
                    str(bookmark3.id),
                ],
            },
        )

        self.assertIsNotNone(Bookmark.objects.filter(id=bookmark1.id).first())
        self.assertIsNotNone(Bookmark.objects.filter(id=bookmark2.id).first())
        self.assertIsNotNone(Bookmark.objects.filter(id=bookmark3.id).first())

    def test_bulk_tag(self):
        bookmark1 = self.setup_bookmark()
        bookmark2 = self.setup_bookmark()
        bookmark3 = self.setup_bookmark()
        tag1 = self.setup_tag()
        tag2 = self.setup_tag()

        self.client.post(
            reverse("linkding:bookmarks.index.action"),
            {
                "bulk_action": ["bulk_tag"],
                "bulk_execute": [""],
                "bulk_tag_string": [f"{tag1.name} {tag2.name}"],
                "bookmark_id": [
                    str(bookmark1.id),
                    str(bookmark2.id),
                    str(bookmark3.id),
                ],
            },
        )

        bookmark1.refresh_from_db()
        bookmark2.refresh_from_db()
        bookmark3.refresh_from_db()

        self.assertCountEqual(bookmark1.tags.all(), [tag1, tag2])
        self.assertCountEqual(bookmark2.tags.all(), [tag1, tag2])
        self.assertCountEqual(bookmark3.tags.all(), [tag1, tag2])

    def test_can_only_bulk_tag_own_bookmarks(self):
        other_user = User.objects.create_user(
            "otheruser", "otheruser@example.com", "password123"
        )
        bookmark1 = self.setup_bookmark(user=other_user)
        bookmark2 = self.setup_bookmark(user=other_user)
        bookmark3 = self.setup_bookmark(user=other_user)
        tag1 = self.setup_tag()
        tag2 = self.setup_tag()

        self.client.post(
            reverse("linkding:bookmarks.index.action"),
            {
                "bulk_action": ["bulk_tag"],
                "bulk_execute": [""],
                "bulk_tag_string": [f"{tag1.name} {tag2.name}"],
                "bookmark_id": [
                    str(bookmark1.id),
                    str(bookmark2.id),
                    str(bookmark3.id),
                ],
            },
        )

        bookmark1.refresh_from_db()
        bookmark2.refresh_from_db()
        bookmark3.refresh_from_db()

        self.assertCountEqual(bookmark1.tags.all(), [])
        self.assertCountEqual(bookmark2.tags.all(), [])
        self.assertCountEqual(bookmark3.tags.all(), [])

    def test_bulk_untag(self):
        tag1 = self.setup_tag()
        tag2 = self.setup_tag()
        bookmark1 = self.setup_bookmark(tags=[tag1, tag2])
        bookmark2 = self.setup_bookmark(tags=[tag1, tag2])
        bookmark3 = self.setup_bookmark(tags=[tag1, tag2])

        self.client.post(
            reverse("linkding:bookmarks.index.action"),
            {
                "bulk_action": ["bulk_untag"],
                "bulk_execute": [""],
                "bulk_tag_string": [f"{tag1.name} {tag2.name}"],
                "bookmark_id": [
                    str(bookmark1.id),
                    str(bookmark2.id),
                    str(bookmark3.id),
                ],
            },
        )

        bookmark1.refresh_from_db()
        bookmark2.refresh_from_db()
        bookmark3.refresh_from_db()

        self.assertCountEqual(bookmark1.tags.all(), [])
        self.assertCountEqual(bookmark2.tags.all(), [])
        self.assertCountEqual(bookmark3.tags.all(), [])

    def test_can_only_bulk_untag_own_bookmarks(self):
        other_user = User.objects.create_user(
            "otheruser", "otheruser@example.com", "password123"
        )
        tag1 = self.setup_tag()
        tag2 = self.setup_tag()
        bookmark1 = self.setup_bookmark(tags=[tag1, tag2], user=other_user)
        bookmark2 = self.setup_bookmark(tags=[tag1, tag2], user=other_user)
        bookmark3 = self.setup_bookmark(tags=[tag1, tag2], user=other_user)

        self.client.post(
            reverse("linkding:bookmarks.index.action"),
            {
                "bulk_action": ["bulk_untag"],
                "bulk_execute": [""],
                "bulk_tag_string": [f"{tag1.name} {tag2.name}"],
                "bookmark_id": [
                    str(bookmark1.id),
                    str(bookmark2.id),
                    str(bookmark3.id),
                ],
            },
        )

        bookmark1.refresh_from_db()
        bookmark2.refresh_from_db()
        bookmark3.refresh_from_db()

        self.assertCountEqual(bookmark1.tags.all(), [tag1, tag2])
        self.assertCountEqual(bookmark2.tags.all(), [tag1, tag2])
        self.assertCountEqual(bookmark3.tags.all(), [tag1, tag2])

    def test_bulk_mark_as_read(self):
        bookmark1 = self.setup_bookmark(unread=True)
        bookmark2 = self.setup_bookmark(unread=True)
        bookmark3 = self.setup_bookmark(unread=True)

        self.client.post(
            reverse("linkding:bookmarks.index.action"),
            {
                "bulk_action": ["bulk_read"],
                "bulk_execute": [""],
                "bookmark_id": [
                    str(bookmark1.id),
                    str(bookmark2.id),
                    str(bookmark3.id),
                ],
            },
        )

        self.assertFalse(Bookmark.objects.get(id=bookmark1.id).unread)
        self.assertFalse(Bookmark.objects.get(id=bookmark2.id).unread)
        self.assertFalse(Bookmark.objects.get(id=bookmark3.id).unread)

    def test_can_only_bulk_mark_as_read_own_bookmarks(self):
        other_user = User.objects.create_user(
            "otheruser", "otheruser@example.com", "password123"
        )
        bookmark1 = self.setup_bookmark(unread=True, user=other_user)
        bookmark2 = self.setup_bookmark(unread=True, user=other_user)
        bookmark3 = self.setup_bookmark(unread=True, user=other_user)

        self.client.post(
            reverse("linkding:bookmarks.index.action"),
            {
                "bulk_action": ["bulk_read"],
                "bulk_execute": [""],
                "bookmark_id": [
                    str(bookmark1.id),
                    str(bookmark2.id),
                    str(bookmark3.id),
                ],
            },
        )

        self.assertTrue(Bookmark.objects.get(id=bookmark1.id).unread)
        self.assertTrue(Bookmark.objects.get(id=bookmark2.id).unread)
        self.assertTrue(Bookmark.objects.get(id=bookmark3.id).unread)

    def test_bulk_mark_as_unread(self):
        bookmark1 = self.setup_bookmark(unread=False)
        bookmark2 = self.setup_bookmark(unread=False)
        bookmark3 = self.setup_bookmark(unread=False)

        self.client.post(
            reverse("linkding:bookmarks.index.action"),
            {
                "bulk_action": ["bulk_unread"],
                "bulk_execute": [""],
                "bookmark_id": [
                    str(bookmark1.id),
                    str(bookmark2.id),
                    str(bookmark3.id),
                ],
            },
        )

        self.assertTrue(Bookmark.objects.get(id=bookmark1.id).unread)
        self.assertTrue(Bookmark.objects.get(id=bookmark2.id).unread)
        self.assertTrue(Bookmark.objects.get(id=bookmark3.id).unread)

    def test_can_only_bulk_mark_as_unread_own_bookmarks(self):
        other_user = User.objects.create_user(
            "otheruser", "otheruser@example.com", "password123"
        )
        bookmark1 = self.setup_bookmark(unread=False, user=other_user)
        bookmark2 = self.setup_bookmark(unread=False, user=other_user)
        bookmark3 = self.setup_bookmark(unread=False, user=other_user)

        self.client.post(
            reverse("linkding:bookmarks.index.action"),
            {
                "bulk_action": ["bulk_unread"],
                "bulk_execute": [""],
                "bookmark_id": [
                    str(bookmark1.id),
                    str(bookmark2.id),
                    str(bookmark3.id),
                ],
            },
        )

        self.assertFalse(Bookmark.objects.get(id=bookmark1.id).unread)
        self.assertFalse(Bookmark.objects.get(id=bookmark2.id).unread)
        self.assertFalse(Bookmark.objects.get(id=bookmark3.id).unread)

    def test_bulk_share(self):
        bookmark1 = self.setup_bookmark(shared=False)
        bookmark2 = self.setup_bookmark(shared=False)
        bookmark3 = self.setup_bookmark(shared=False)

        self.client.post(
            reverse("linkding:bookmarks.index.action"),
            {
                "bulk_action": ["bulk_share"],
                "bulk_execute": [""],
                "bookmark_id": [
                    str(bookmark1.id),
                    str(bookmark2.id),
                    str(bookmark3.id),
                ],
            },
        )

        self.assertTrue(Bookmark.objects.get(id=bookmark1.id).shared)
        self.assertTrue(Bookmark.objects.get(id=bookmark2.id).shared)
        self.assertTrue(Bookmark.objects.get(id=bookmark3.id).shared)

    def test_can_only_bulk_share_own_bookmarks(self):
        other_user = User.objects.create_user(
            "otheruser", "otheruser@example.com", "password123"
        )
        bookmark1 = self.setup_bookmark(shared=False, user=other_user)
        bookmark2 = self.setup_bookmark(shared=False, user=other_user)
        bookmark3 = self.setup_bookmark(shared=False, user=other_user)

        self.client.post(
            reverse("linkding:bookmarks.index.action"),
            {
                "bulk_action": ["bulk_share"],
                "bulk_execute": [""],
                "bookmark_id": [
                    str(bookmark1.id),
                    str(bookmark2.id),
                    str(bookmark3.id),
                ],
            },
        )

        self.assertFalse(Bookmark.objects.get(id=bookmark1.id).shared)
        self.assertFalse(Bookmark.objects.get(id=bookmark2.id).shared)
        self.assertFalse(Bookmark.objects.get(id=bookmark3.id).shared)

    def test_bulk_unshare(self):
        bookmark1 = self.setup_bookmark(shared=True)
        bookmark2 = self.setup_bookmark(shared=True)
        bookmark3 = self.setup_bookmark(shared=True)

        self.client.post(
            reverse("linkding:bookmarks.index.action"),
            {
                "bulk_action": ["bulk_unshare"],
                "bulk_execute": [""],
                "bookmark_id": [
                    str(bookmark1.id),
                    str(bookmark2.id),
                    str(bookmark3.id),
                ],
            },
        )

        self.assertFalse(Bookmark.objects.get(id=bookmark1.id).shared)
        self.assertFalse(Bookmark.objects.get(id=bookmark2.id).shared)
        self.assertFalse(Bookmark.objects.get(id=bookmark3.id).shared)

    def test_can_only_bulk_unshare_own_bookmarks(self):
        other_user = User.objects.create_user(
            "otheruser", "otheruser@example.com", "password123"
        )
        bookmark1 = self.setup_bookmark(shared=True, user=other_user)
        bookmark2 = self.setup_bookmark(shared=True, user=other_user)
        bookmark3 = self.setup_bookmark(shared=True, user=other_user)

        self.client.post(
            reverse("linkding:bookmarks.index.action"),
            {
                "bulk_action": ["bulk_unshare"],
                "bulk_execute": [""],
                "bookmark_id": [
                    str(bookmark1.id),
                    str(bookmark2.id),
                    str(bookmark3.id),
                ],
            },
        )

        self.assertTrue(Bookmark.objects.get(id=bookmark1.id).shared)
        self.assertTrue(Bookmark.objects.get(id=bookmark2.id).shared)
        self.assertTrue(Bookmark.objects.get(id=bookmark3.id).shared)

    def test_bulk_select_across(self):
        bookmark1 = self.setup_bookmark()
        bookmark2 = self.setup_bookmark()
        bookmark3 = self.setup_bookmark()

        self.client.post(
            reverse("linkding:bookmarks.index.action"),
            {
                "bulk_action": ["bulk_archive"],
                "bulk_execute": [""],
                "bulk_select_across": ["on"],
            },
        )

        self.assertTrue(Bookmark.objects.get(id=bookmark1.id).is_archived)
        self.assertTrue(Bookmark.objects.get(id=bookmark2.id).is_archived)
        self.assertTrue(Bookmark.objects.get(id=bookmark3.id).is_archived)

    def test_bulk_select_across_ignores_page(self):
        self.setup_numbered_bookmarks(100)

        self.client.post(
            reverse("linkding:bookmarks.index.action") + "?page=2",
            {
                "bulk_action": ["bulk_delete"],
                "bulk_execute": [""],
                "bulk_select_across": ["on"],
            },
        )

        self.assertEqual(0, Bookmark.objects.count())

    def setup_bulk_edit_scope_test_data(self):
        # create a number of bookmarks with different states / visibility
        self.setup_numbered_bookmarks(3, with_tags=True)
        self.setup_numbered_bookmarks(3, with_tags=True, archived=True)
        self.setup_numbered_bookmarks(
            3,
            shared=True,
            prefix="Joe's Bookmark",
            user=self.setup_user(enable_sharing=True),
        )

    def test_index_action_bulk_select_across_only_affects_active_bookmarks(self):
        self.setup_bulk_edit_scope_test_data()

        self.assertIsNotNone(Bookmark.objects.filter(title="Bookmark 1").first())
        self.assertIsNotNone(Bookmark.objects.filter(title="Bookmark 2").first())
        self.assertIsNotNone(Bookmark.objects.filter(title="Bookmark 3").first())

        self.client.post(
            reverse("linkding:bookmarks.index.action"),
            {
                "bulk_action": ["bulk_delete"],
                "bulk_execute": [""],
                "bulk_select_across": ["on"],
            },
        )

        self.assertEqual(6, Bookmark.objects.count())
        self.assertIsNone(Bookmark.objects.filter(title="Bookmark 1").first())
        self.assertIsNone(Bookmark.objects.filter(title="Bookmark 2").first())
        self.assertIsNone(Bookmark.objects.filter(title="Bookmark 3").first())

    def test_index_action_bulk_select_across_respects_query(self):
        self.setup_numbered_bookmarks(3, prefix="foo")
        self.setup_numbered_bookmarks(3, prefix="bar")

        self.assertEqual(3, Bookmark.objects.filter(title__startswith="foo").count())

        self.client.post(
            reverse("linkding:bookmarks.index.action") + "?q=foo",
            {
                "bulk_action": ["bulk_delete"],
                "bulk_execute": [""],
                "bulk_select_across": ["on"],
            },
        )

        self.assertEqual(0, Bookmark.objects.filter(title__startswith="foo").count())
        self.assertEqual(3, Bookmark.objects.filter(title__startswith="bar").count())

    def test_index_action_bulk_select_across_respects_bundle(self):
        self.setup_numbered_bookmarks(3, prefix="foo")
        self.setup_numbered_bookmarks(3, prefix="bar")

        self.assertEqual(3, Bookmark.objects.filter(title__startswith="foo").count())

        bundle = self.setup_bundle(search="foo")

        self.client.post(
            reverse("linkding:bookmarks.index.action") + f"?bundle={bundle.id}",
            {
                "bulk_action": ["bulk_delete"],
                "bulk_execute": [""],
                "bulk_select_across": ["on"],
            },
        )

        self.assertEqual(0, Bookmark.objects.filter(title__startswith="foo").count())
        self.assertEqual(3, Bookmark.objects.filter(title__startswith="bar").count())

    def test_archived_action_bulk_select_across_only_affects_archived_bookmarks(self):
        self.setup_bulk_edit_scope_test_data()

        self.assertIsNotNone(
            Bookmark.objects.filter(title="Archived Bookmark 1").first()
        )
        self.assertIsNotNone(
            Bookmark.objects.filter(title="Archived Bookmark 2").first()
        )
        self.assertIsNotNone(
            Bookmark.objects.filter(title="Archived Bookmark 3").first()
        )

        self.client.post(
            reverse("linkding:bookmarks.archived.action"),
            {
                "bulk_action": ["bulk_delete"],
                "bulk_execute": [""],
                "bulk_select_across": ["on"],
            },
        )

        self.assertEqual(6, Bookmark.objects.count())
        self.assertIsNone(Bookmark.objects.filter(title="Archived Bookmark 1").first())
        self.assertIsNone(Bookmark.objects.filter(title="Archived Bookmark 2").first())
        self.assertIsNone(Bookmark.objects.filter(title="Archived Bookmark 3").first())

    def test_archived_action_bulk_select_across_respects_query(self):
        self.setup_numbered_bookmarks(3, prefix="foo", archived=True)
        self.setup_numbered_bookmarks(3, prefix="bar", archived=True)

        self.assertEqual(3, Bookmark.objects.filter(title__startswith="foo").count())

        self.client.post(
            reverse("linkding:bookmarks.archived.action") + "?q=foo",
            {
                "bulk_action": ["bulk_delete"],
                "bulk_execute": [""],
                "bulk_select_across": ["on"],
            },
        )

        self.assertEqual(0, Bookmark.objects.filter(title__startswith="foo").count())
        self.assertEqual(3, Bookmark.objects.filter(title__startswith="bar").count())

    def test_archived_action_bulk_select_across_respects_bundle(self):
        self.setup_numbered_bookmarks(3, prefix="foo", archived=True)
        self.setup_numbered_bookmarks(3, prefix="bar", archived=True)

        self.assertEqual(3, Bookmark.objects.filter(title__startswith="foo").count())

        bundle = self.setup_bundle(search="foo")

        self.client.post(
            reverse("linkding:bookmarks.archived.action") + f"?bundle={bundle.id}",
            {
                "bulk_action": ["bulk_delete"],
                "bulk_execute": [""],
                "bulk_select_across": ["on"],
            },
        )

        self.assertEqual(0, Bookmark.objects.filter(title__startswith="foo").count())
        self.assertEqual(3, Bookmark.objects.filter(title__startswith="bar").count())

    def test_shared_action_bulk_select_across_not_supported(self):
        self.setup_bulk_edit_scope_test_data()

        response = self.client.post(
            reverse("linkding:bookmarks.shared.action"),
            {
                "bulk_action": ["bulk_delete"],
                "bulk_execute": [""],
                "bulk_select_across": ["on"],
            },
        )
        self.assertEqual(response.status_code, 400)

    def test_handles_empty_bookmark_id(self):
        bookmark1 = self.setup_bookmark()
        bookmark2 = self.setup_bookmark()
        bookmark3 = self.setup_bookmark()

        response = self.client.post(
            reverse("linkding:bookmarks.index.action"),
            {
                "bulk_action": ["bulk_archive"],
                "bulk_execute": [""],
            },
        )
        self.assertEqual(response.status_code, 302)

        response = self.client.post(
            reverse("linkding:bookmarks.index.action"),
            {
                "bulk_action": ["bulk_archive"],
                "bulk_execute": [""],
                "bookmark_id": [],
            },
        )
        self.assertEqual(response.status_code, 302)

        self.assertBookmarksAreUnmodified([bookmark1, bookmark2, bookmark3])

    def test_empty_action_does_not_modify_bookmarks(self):
        bookmark1 = self.setup_bookmark()
        bookmark2 = self.setup_bookmark()
        bookmark3 = self.setup_bookmark()

        self.client.post(
            reverse("linkding:bookmarks.index.action"),
            {
                "bookmark_id": [
                    str(bookmark1.id),
                    str(bookmark2.id),
                    str(bookmark3.id),
                ],
            },
        )

        self.assertBookmarksAreUnmodified([bookmark1, bookmark2, bookmark3])

    def test_index_action_redirects_to_index_with_query_params(self):
        url = reverse("linkding:bookmarks.index.action") + "?q=foo&page=2"
        redirect_url = reverse("linkding:bookmarks.index") + "?q=foo&page=2"
        response = self.client.post(url)

        self.assertRedirects(response, redirect_url)

    def test_archived_action_redirects_to_archived_with_query_params(self):
        url = reverse("linkding:bookmarks.archived.action") + "?q=foo&page=2"
        redirect_url = reverse("linkding:bookmarks.archived") + "?q=foo&page=2"
        response = self.client.post(url)

        self.assertRedirects(response, redirect_url)

    def test_shared_action_redirects_to_shared_with_query_params(self):
        url = reverse("linkding:bookmarks.shared.action") + "?q=foo&page=2"
        redirect_url = reverse("linkding:bookmarks.shared") + "?q=foo&page=2"
        response = self.client.post(url)

        self.assertRedirects(response, redirect_url)

    def bookmark_update_fixture(self):
        user = self.get_or_create_test_user()
        profile = user.profile
        profile.enable_sharing = True
        profile.save()

        return {
            "active": self.setup_numbered_bookmarks(3),
            "archived": self.setup_numbered_bookmarks(3, archived=True),
            "shared": self.setup_numbered_bookmarks(3, shared=True),
        }

    def assertBookmarkUpdateResponse(self, response: HttpResponse):
        self.assertEqual(response.status_code, 200)

        html = response.content.decode("utf-8")
        soup = self.make_soup(html)

        # bookmark list update
        self.assertIsNotNone(
            soup.select_one(
                "turbo-stream[action='update'][target='bookmark-list-container']"
            )
        )

        # tag cloud update
        self.assertIsNotNone(
            soup.select_one(
                "turbo-stream[action='update'][target='tag-cloud-container']"
            )
        )

        # update event
        self.assertInHTML(
            """
            <script>
                document.dispatchEvent(new CustomEvent('bookmark-list-updated'));
            </script>
            """,
            html,
        )

    def test_index_action_with_turbo_returns_bookmark_update(self):
        fixture = self.bookmark_update_fixture()
        response = self.client.post(
            reverse("linkding:bookmarks.index.action"),
            HTTP_ACCEPT="text/vnd.turbo-stream.html",
        )

        visible_tags = self.get_tags_from_bookmarks(
            fixture["active"] + fixture["shared"]
        )
        invisible_tags = self.get_tags_from_bookmarks(fixture["archived"])

        self.assertBookmarkUpdateResponse(response)
        self.assertVisibleBookmarks(response, fixture["active"] + fixture["shared"])
        self.assertInvisibleBookmarks(response, fixture["archived"])
        self.assertVisibleTags(response, visible_tags)
        self.assertInvisibleTags(response, invisible_tags)

    def test_archived_action_with_turbo_returns_bookmark_update(self):
        fixture = self.bookmark_update_fixture()
        response = self.client.post(
            reverse("linkding:bookmarks.archived.action"),
            HTTP_ACCEPT="text/vnd.turbo-stream.html",
        )

        visible_tags = self.get_tags_from_bookmarks(fixture["archived"])
        invisible_tags = self.get_tags_from_bookmarks(
            fixture["active"] + fixture["shared"]
        )

        self.assertBookmarkUpdateResponse(response)
        self.assertVisibleBookmarks(response, fixture["archived"])
        self.assertInvisibleBookmarks(response, fixture["active"] + fixture["shared"])
        self.assertVisibleTags(response, visible_tags)
        self.assertInvisibleTags(response, invisible_tags)

    def test_shared_action_with_turbo_returns_bookmark_update(self):
        fixture = self.bookmark_update_fixture()
        response = self.client.post(
            reverse("linkding:bookmarks.shared.action"),
            HTTP_ACCEPT="text/vnd.turbo-stream.html",
        )

        visible_tags = self.get_tags_from_bookmarks(fixture["shared"])
        invisible_tags = self.get_tags_from_bookmarks(
            fixture["active"] + fixture["archived"]
        )

        self.assertBookmarkUpdateResponse(response)
        self.assertVisibleBookmarks(response, fixture["shared"])
        self.assertInvisibleBookmarks(response, fixture["active"] + fixture["archived"])
        self.assertVisibleTags(response, visible_tags)
        self.assertInvisibleTags(response, invisible_tags)


================================================
FILE: bookmarks/tests/test_bookmark_archived_view.py
================================================
import urllib.parse

from django.contrib.auth.models import User
from django.test import TestCase, override_settings
from django.urls import reverse

from bookmarks.models import BookmarkSearch, UserProfile
from bookmarks.tests.helpers import (
    BookmarkFactoryMixin,
    BookmarkListTestMixin,
    TagCloudTestMixin,
)


class BookmarkArchivedViewTestCase(
    TestCase, BookmarkFactoryMixin, BookmarkListTestMixin, TagCloudTestMixin
):
    def setUp(self) -> None:
        user = self.get_or_create_test_user()
        self.client.force_login(user)

    def assertEditLink(self, response, url):
        html = response.content.decode()
        self.assertInHTML(
            f"""
            <a href="{url}">Edit</a>        
        """,
            html,
        )

    def assertBulkActionForm(self, response, url: str):
        soup = self.make_soup(response.content.decode())
        form = soup.select_one("form.bookmark-actions")
        self.assertIsNotNone(form)
        self.assertEqual(form.attrs["action"], url)

    def test_should_list_archived_and_user_owned_bookmarks(self):
        other_user = User.objects.create_user(
            "otheruser", "otheruser@example.com", "password123"
        )
        visible_bookmarks = self.setup_numbered_bookmarks(3, archived=True)
        invisible_bookmarks = [
            self.setup_bookmark(is_archived=False),
            self.setup_bookmark(is_archived=True, user=other_user),
        ]

        response = self.client.get(reverse("linkding:bookmarks.archived"))

        self.assertVisibleBookmarks(response, visible_bookmarks)
        self.assertInvisibleBookmarks(response, invisible_bookmarks)

    def test_should_list_bookmarks_matching_query(self):
        visible_bookmarks = self.setup_numbered_bookmarks(
            3, prefix="foo", archived=True
        )
        invisible_bookmarks = self.setup_numbered_bookmarks(
            3, prefix="bar", archived=True
        )

        response = self.client.get(reverse("linkding:bookmarks.archived") + "?q=foo")

        self.assertVisibleBookmarks(response, visible_bookmarks)
        self.assertInvisibleBookmarks(response, invisible_bookmarks)

    def test_should_list_bookmarks_matching_bundle(self):
        visible_bookmarks = self.setup_numbered_bookmarks(
            3, prefix="foo", archived=True
        )
        invisible_bookmarks = self.setup_numbered_bookmarks(
            3, prefix="bar", archived=True
        )

        bundle = self.setup_bundle(search="foo")

        response = self.client.get(
            reverse("linkding:bookmarks.archived") + f"?bundle={bundle.id}"
        )

        self.assertVisibleBookmarks(response, visible_bookmarks)
        self.assertInvisibleBookmarks(response, invisible_bookmarks)

    def test_should_list_tags_for_archived_and_user_owned_bookmarks(self):
        other_user = User.objects.create_user(
            "otheruser", "otheruser@example.com", "password123"
        )
        visible_bookmarks = self.setup_numbered_bookmarks(
            3, with_tags=True, archived=True
        )
        unarchived_bookmarks = self.setup_numbered_bookmarks(
            3, with_tags=True, archived=False, tag_prefix="unarchived"
        )
        other_user_bookmarks = self.setup_numbered_bookmarks(
            3, with_tags=True, archived=True, user=other_user, tag_prefix="otheruser"
        )

        visible_tags = self.get_tags_from_bookmarks(visible_bookmarks)
        invisible_tags = self.get_tags_from_bookmarks(
            unarchived_bookmarks + other_user_bookmarks
        )

        response = self.client.get(reverse("linkding:bookmarks.archived"))

        self.assertVisibleTags(response, visible_tags)
        self.assertInvisibleTags(response, invisible_tags)

    def test_should_list_tags_for_bookmarks_matching_query(self):
        visible_bookmarks = self.setup_numbered_bookmarks(
            3, with_tags=True, archived=True, prefix="foo", tag_prefix="foo"
        )
        invisible_bookmarks = self.setup_numbered_bookmarks(
            3, with_tags=True, archived=True, prefix="bar", tag_prefix="bar"
        )

        visible_tags = self.get_tags_from_bookmarks(visible_bookmarks)
        invisible_tags = self.get_tags_from_bookmarks(invisible_bookmarks)

        response = self.client.get(reverse("linkding:bookmarks.archived") + "?q=foo")

        self.assertVisibleTags(response, visible_tags)
        self.assertInvisibleTags(response, invisible_tags)

    def test_should_list_tags_for_bookmarks_matching_bundle(self):
        visible_bookmarks = self.setup_numbered_bookmarks(
            3, with_tags=True, archived=True, prefix="foo", tag_prefix="foo"
        )
        invisible_bookmarks = self.setup_numbered_bookmarks(
            3, with_tags=True, archived=True, prefix="bar", tag_prefix="bar"
        )

        visible_tags = self.get_tags_from_bookmarks(visible_bookmarks)
        invisible_tags = self.get_tags_from_bookmarks(invisible_bookmarks)

        bundle = self.setup_bundle(search="foo")

        response = self.client.get(
            reverse("linkding:bookmarks.archived") + f"?bundle={bundle.id}"
        )

        self.assertVisibleTags(response, visible_tags)
        self.assertInvisibleTags(response, invisible_tags)

    def test_should_list_bookmarks_and_tags_for_search_preferences(self):
        user_profile = self.user.profile
        user_profile.search_preferences = {
            "unread": BookmarkSearch.FILTER_UNREAD_YES,
        }
        user_profile.save()

        unread_bookmarks = self.setup_numbered_bookmarks(
            3,
            archived=True,
            unread=True,
            with_tags=True,
            prefix="unread",
            tag_prefix="unread",
        )
        read_bookmarks = self.setup_numbered_bookmarks(
            3,
            archived=True,
            unread=False,
            with_tags=True,
            prefix="read",
            tag_prefix="read",
        )

        unread_tags = self.get_tags_from_bookmarks(unread_bookmarks)
        read_tags = self.get_tags_from_bookmarks(read_bookmarks)

        response = self.client.get(reverse("linkding:bookmarks.archived"))
        self.assertVisibleBookmarks(response, unread_bookmarks)
        self.assertInvisibleBookmarks(response, read_bookmarks)
        self.assertVisibleTags(response, unread_tags)
        self.assertInvisibleTags(response, read_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("linkding: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("linkding: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("linkding: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_numbered_bookmarks(3, archived=True)

        response = self.client.get(reverse("linkding:bookmarks.archived"))

        self.assertVisibleBookmarks(response, visible_bookmarks, "_blank")

    def test_should_open_bookmarks_in_same_page_if_specified_in_user_profile(self):
        user = self.get_or_create_test_user()
        user.profile.bookmark_link_target = UserProfile.BOOKMARK_LINK_TARGET_SELF
        user.profile.save()

        visible_bookmarks = self.setup_numbered_bookmarks(3, archived=True)

        response = self.client.get(reverse("linkding:bookmarks.archived"))

        self.assertVisibleBookmarks(response, visible_bookmarks, "_self")

    def test_edit_link_return_url_respects_search_options(self):
        bookmark = self.setup_bookmark(title="foo", is_archived=True)
        edit_url = reverse("linkding:bookmarks.edit", args=[bookmark.id])
        base_url = reverse("linkding:bookmarks.archived")

        # without query params
        return_url = urllib.parse.quote(base_url)
        url = f"{edit_url}?return_url={return_url}"

        response = self.client.get(base_url)
        self.assertEditLink(response, url)

        # with query
        url_params = "?q=foo"
        return_url = urllib.parse.quote(base_url + url_params)
        url = f"{edit_url}?return_url={return_url}"

        response = self.client.get(base_url + url_params)
        self.assertEditLink(response, url)

        # with query and sort and page
        url_params = "?q=foo&sort=title_asc&page=2"
        return_url = urllib.parse.quote(base_url + url_params)
        url = f"{edit_url}?return_url={return_url}"

        response = self.client.get(base_url + url_params)
        self.assertEditLink(response, url)

    def test_bulk_edit_respects_search_options(self):
        action_url = reverse("linkding:bookmarks.archived.action")
        base_url = reverse("linkding:bookmarks.archived")

        # without params
        url = f"{action_url}"

        response = self.client.get(base_url)
        self.assertBulkActionForm(response, url)

        # with query
        url_params = "?q=foo"
        url = f"{action_url}?q=foo"

        response = self.client.get(base_url + url_params)
        self.assertBulkActionForm(response, url)

        # with query and sort
        url_params = "?q=foo&sort=title_asc"
        url = f"{action_url}?q=foo&sort=title_asc"

        response = self.client.get(base_url + url_params)
        self.assertBulkActionForm(response, url)

    def test_allowed_bulk_actions(self):
        url = reverse("linkding:bookmarks.archived")
        response = self.client.get(url)
        html = response.content.decode()

        self.assertInHTML(
            """
          <select name="bulk_action" class="form-select select-sm">
            <option value="bulk_unarchive">Unarchive</option>
            <option value="bulk_delete">Delete</option>
            <option value="bulk_tag">Add tags</option>
            <option value="bulk_untag">Remove tags</option>
            <option value="bulk_read">Mark as read</option>
            <option value="bulk_unread">Mark as unread</option>
            <option value="bulk_refresh">Refresh from website</option>
          </select>
        """,
            html,
        )

    @override_settings(LD_ENABLE_SNAPSHOTS=True)
    def test_allowed_bulk_actions_with_html_snapshot_enabled(self):
        url = reverse("linkding:bookmarks.archived")
        response = self.client.get(url)
        html = response.content.decode()

        self.assertInHTML(
            """
          <select name="bulk_action" class="form-select select-sm">
            <option value="bulk_unarchive">Unarchive</option>
            <option value="bulk_delete">Delete</option>
            <option value="bulk_tag">Add tags</option>
            <option value="bulk_untag">Remove tags</option>
            <option value="bulk_read">Mark as read</option>
            <option value="bulk_unread">Mark as unread</option>
            <option value="bulk_refresh">Refresh from website</option>
            <option value="bulk_snapshot">Create HTML snapshot</option>
          </select>
        """,
            html,
        )

    def test_allowed_bulk_actions_with_sharing_enabled(self):
        user_profile = self.user.profile
        user_profile.enable_sharing = True
        user_profile.save()

        url = reverse("linkding:bookmarks.archived")
        response = self.client.get(url)
        html = response.content.decode()

        self.assertInHTML(
            """
          <select name="bulk_action" class="form-select select-sm">
            <option value="bulk_unarchive">Unarchive</option>
            <option value="bulk_delete">Delete</option>
            <option value="bulk_tag">Add tags</option>
            <option value="bulk_untag">Remove tags</option>
            <option value="bulk_read">Mark as read</option>
            <option value="bulk_unread">Mark as unread</option>
            <option value="bulk_share">Share</option>
            <option value="bulk_unshare">Unshare</option>
            <option value="bulk_refresh">Refresh from website</option>
          </select>
        """,
            html,
        )

    @override_settings(LD_ENABLE_SNAPSHOTS=True)
    def test_allowed_bulk_actions_with_sharing_and_html_snapshot_enabled(self):
        user_profile = self.user.profile
        user_profile.enable_sharing = True
        user_profile.save()

        url = reverse("linkding:bookmarks.archived")
        response = self.client.get(url)
        html = response.content.decode()

        self.assertInHTML(
            """
          <select name="bulk_action" class="form-select select-sm">
            <option value="bulk_unarchive">Unarchive</option>
            <option value="bulk_delete">Delete</option>
            <option value="bulk_tag">Add tags</option>
            <option value="bulk_untag">Remove tags</option>
            <option value="bulk_read">Mark as read</option>
            <option value="bulk_unread">Mark as unread</option>
            <option value="bulk_share">Share</option>
            <option value="bulk_unshare">Unshare</option>
            <option value="bulk_refresh">Refresh from website</option>
            <option value="bulk_snapshot">Create HTML snapshot</option>
          </select>
        """,
            html,
        )

    def test_apply_search_preferences(self):
        # no params
        response = self.client.post(reverse("linkding:bookmarks.archived"))
        self.assertEqual(response.status_code, 302)
        self.assertEqual(response.url, reverse("linkding:bookmarks.archived"))

        # some params
        response = self.client.post(
            reverse("linkding:bookmarks.archived"),
            {
                "q": "foo",
                "sort": BookmarkSearch.SORT_TITLE_ASC,
            },
        )
        self.assertEqual(response.status_code, 302)
        self.assertEqual(
            response.url,
            reverse("linkding:bookmarks.archived") + "?q=foo&sort=title_asc",
        )

        # params with default value are removed
        response = self.client.post(
            reverse("linkding:bookmarks.archived"),
            {
                "q": "foo",
                "user": "",
                "sort": BookmarkSearch.SORT_ADDED_DESC,
                "shared": BookmarkSearch.FILTER_SHARED_OFF,
                "unread": BookmarkSearch.FILTER_UNREAD_YES,
            },
        )
        self.assertEqual(response.status_code, 302)
        self.assertEqual(
            response.url, reverse("linkding:bookmarks.archived") + "?q=foo&unread=yes"
        )

        # page is removed
        response = self.client.post(
            reverse("linkding:bookmarks.archived"),
            {
                "q": "foo",
                "page": "2",
                "sort": BookmarkSearch.SORT_TITLE_ASC,
            },
        )
        self.assertEqual(response.status_code, 302)
        self.assertEqual(
            response.url,
            reverse("linkding:bookmarks.archived") + "?q=foo&sort=title_asc",
        )

    def test_save_search_preferences(self):
        user_profile = self.user.profile

        # no params
        self.client.post(
            reverse("linkding:bookmarks.archived"),
            {
                "save": "",
            },
        )
        user_profile.refresh_from_db()
        self.assertEqual(
            user_profile.search_preferences,
            {
                "sort": BookmarkSearch.SORT_ADDED_DESC,
                "shared": BookmarkSearch.FILTER_SHARED_OFF,
                "unread": BookmarkSearch.FILTER_UNREAD_OFF,
            },
        )

        # with param
        self.client.post(
            reverse("linkding:bookmarks.archived"),
            {
                "save": "",
                "sort": BookmarkSearch.SORT_TITLE_ASC,
            },
        )
        user_profile.refresh_from_db()
        self.assertEqual(
            user_profile.search_preferences,
            {
                "sort": BookmarkSearch.SORT_TITLE_ASC,
                "shared": BookmarkSearch.FILTER_SHARED_OFF,
                "unread": BookmarkSearch.FILTER_UNREAD_OFF,
            },
        )

        # add a param
        self.client.post(
            reverse("linkding:bookmarks.archived"),
            {
                "save": "",
                "sort": BookmarkSearch.SORT_TITLE_ASC,
                "unread": BookmarkSearch.FILTER_UNREAD_YES,
            },
        )
        user_profile.refresh_from_db()
        self.assertEqual(
            user_profile.search_preferences,
            {
                "sort": BookmarkSearch.SORT_TITLE_ASC,
                "shared": BookmarkSearch.FILTER_SHARED_OFF,
                "unread": BookmarkSearch.FILTER_UNREAD_YES,
            },
        )

        # remove a param
        self.client.post(
            reverse("linkding:bookmarks.archived"),
            {
                "save": "",
                "unread": BookmarkSearch.FILTER_UNREAD_YES,
            },
        )
        user_profile.refresh_from_db()
        self.assertEqual(
            user_profile.search_preferences,
            {
                "sort": BookmarkSearch.SORT_ADDED_DESC,
                "shared": BookmarkSearch.FILTER_SHARED_OFF,
                "unread": BookmarkSearch.FILTER_UNREAD_YES,
            },
        )

        # ignores non-preferences
        self.client.post(
            reverse("linkding:bookmarks.archived"),
            {
                "save": "",
                "q": "foo",
                "user": "john",
                "page": "3",
                "sort": BookmarkSearch.SORT_TITLE_ASC,
            },
        )
        user_profile.refresh_from_db()
        self.assertEqual(
            user_profile.search_preferences,
            {
                "sort": BookmarkSearch.SORT_TITLE_ASC,
                "shared": BookmarkSearch.FILTER_SHARED_OFF,
                "unread": BookmarkSearch.FILTER_UNREAD_OFF,
            },
        )

    def test_url_encode_bookmark_actions_url(self):
        url = reverse("linkding:bookmarks.archived") + "?q=%23foo"
        response = self.client.get(url)
        html = response.content.decode()
        soup = self.make_soup(html)
        actions_form = soup.select("form.bookmark-actions")[0]

        self.assertEqual(
            actions_form.attrs["action"],
            "/bookmarks/archived/action?q=%23foo",
        )

    def test_encode_search_params(self):
        bookmark = self.setup_bookmark(description="alert('xss')", is_archived=True)

        url = reverse("linkding:bookmarks.archived") + "?q=alert(%27xss%27)"
        response = self.client.get(url)
        self.assertNotContains(response, "alert('xss')")
        self.assertContains(response, bookmark.url)

        url = reverse("linkding:bookmarks.archived") + "?sort=alert(%27xss%27)"
        response = self.client.get(url)
        self.assertNotContains(response, "alert('xss')")

        url = reverse("linkding:bookmarks.archived") + "?unread=alert(%27xss%27)"
        response = self.client.get(url)
        self.assertNotContains(response, "alert('xss')")

        url = reverse("linkding:bookmarks.archived") + "?shared=alert(%27xss%27)"
        response = self.client.get(url)
        self.assertNotContains(response, "alert('xss')")

        url = reverse("linkding:bookmarks.archived") + "?user=alert(%27xss%27)"
        response = self.client.get(url)
        self.assertNotContains(response, "alert('xss')")

        url = reverse("linkding:bookmarks.archived") + "?page=alert(%27xss%27)"
        response = self.client.get(url)
        self.assertNotContains(response, "alert('xss')")

    def test_turbo_frame_details_modal_renders_details_modal_update(self):
        bookmark = self.setup_bookmark()
        url = reverse("linkding:bookmarks.archived") + f"?bookmark_id={bookmark.id}"
        response = self.client.get(url, headers={"Turbo-Frame": "details-modal"})

        self.assertEqual(200, response.status_code)

        soup = self.make_soup(response.content.decode())
        self.assertIsNotNone(soup.select_one("turbo-frame#details-modal"))
        self.assertIsNone(soup.select_one("#bookmark-list-container"))
        self.assertIsNone(soup.select_one("#tag-cloud-container"))

    def test_does_not_include_rss_feed(self):
        response = self.client.get(reverse("linkding:bookmarks.archived"))
        soup = self.make_soup(response.content.decode())

        feed = soup.select_one('head link[type="application/rss+xml"]')
        self.assertIsNone(feed)

    def test_hide_bundles_when_enabled_in_profile(self):
        # visible by default
        response = self.client.get(reverse("linkding:bookmarks.archived"))
        html = response.content.decode()

        self.assertInHTML('<h2 id="bundles-heading">Bundles</h2>', html)

        # hidden when disabled in profile
        user_profile = self.get_or_create_test_user().profile
        user_profile.hide_bundles = True
        user_profile.save()

        response = self.client.get(reverse("linkding:bookmarks.archived"))
        html = response.content.decode()

        self.assertInHTML('<h2 id="bundles-heading">Bundles</h2>', html, count=0)


================================================
FILE: bookmarks/tests/test_bookmark_archived_view_performance.py
================================================
from django.db import connections
from django.db.utils import DEFAULT_DB_ALIAS
from django.test import TransactionTestCase
from django.test.utils import CaptureQueriesContext
from django.urls import reverse

from bookmarks.models import GlobalSettings
from bookmarks.tests.helpers import BookmarkFactoryMixin, HtmlTestMixin


class BookmarkArchivedViewPerformanceTestCase(
    TransactionTestCase, BookmarkFactoryMixin, HtmlTestMixin
):
    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 global settings
        GlobalSettings.get()

        # create initial bookmarks
        num_initial_bookmarks = 10
        for _ 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("linkding:bookmarks.archived"))
            html = response.content.decode("utf-8")
            soup = self.make_soup(html)
            list_items = soup.select("ul.bookmark-list > li")
            self.assertEqual(len(list_items), num_initial_bookmarks)

        number_of_queries = context.final_queries

        # add more bookmarks
        num_additional_bookmarks = 10
        for _ 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("linkding:bookmarks.archived"))
            html = response.content.decode("utf-8")
            soup = self.make_soup(html)
            list_items = soup.select("ul.bookmark-list > li")
            self.assertEqual(
                len(list_items), num_initial_bookmarks + num_additional_bookmarks
            )


================================================
FILE: bookmarks/tests/test_bookmark_asset_view.py
================================================
import os

from django.conf import settings
from django.test import TestCase
from django.urls import reverse

from bookmarks.models import BookmarkAsset
from bookmarks.tests.helpers import BookmarkFactoryMixin


class BookmarkAssetViewTestCase(TestCase, BookmarkFactoryMixin):
    def setUp(self) -> None:
        self.setup_temp_assets_dir()
        user = self.get_or_create_test_user()
        self.client.force_login(user)

    def setup_asset_file(self, filename):
        filepath = os.path.join(settings.LD_ASSET_FOLDER, filename)
        with open(filepath, "w") as f:
            f.write("test")

    def setup_asset_with_file(self, bookmark):
        filename = f"temp_{bookmark.id}.html.gzip"
        self.setup_asset_file(filename)
        asset = self.setup_asset(
            bookmark=bookmark, file=filename, display_name=f"Snapshot {bookmark.id}"
        )
        return asset

    def setup_asset_with_uploaded_file(self, bookmark, content_type="image/png"):
        filename = f"temp_{bookmark.id}.png.gzip"
        self.setup_asset_file(filename)
        asset = self.setup_asset(
            bookmark=bookmark,
            file=filename,
            asset_type=BookmarkAsset.TYPE_UPLOAD,
            content_type=content_type,
            display_name=f"Uploaded file {bookmark.id}.png",
        )
        return asset

    def view_access_test(self, view_name: str):
        # own bookmark
        bookmark = self.setup_bookmark()
        asset = self.setup_asset_with_file(bookmark)

        response = self.client.get(reverse(view_name, args=[asset.id]))
        self.assertEqual(response.status_code, 200)

        # other user's bookmark
        other_user = self.setup_user()
        bookmark = self.setup_bookmark(user=other_user)
        asset = self.setup_asset_with_file(bookmark)

        response = self.client.get(reverse(view_name, args=[asset.id]))
        self.assertEqual(response.status_code, 404)

        # shared, sharing disabled
        bookmark = self.setup_bookmark(user=other_user, shared=True)
        asset = self.setup_asset_with_file(bookmark)

        response = self.client.get(reverse(view_name, args=[asset.id]))
        self.assertEqual(response.status_code, 404)

        # unshared, sharing enabled
        profile = other_user.profile
        profile.enable_sharing = True
        profile.save()
        bookmark = self.setup_bookmark(user=other_user, shared=False)
        asset = self.setup_asset_with_file(bookmark)

        response = self.client.get(reverse(view_name, args=[asset.id]))
        self.assertEqual(response.status_code, 404)

        # shared, sharing enabled
        bookmark = self.setup_bookmark(user=other_user, shared=True)
        asset = self.setup_asset_with_file(bookmark)

        response = self.client.get(reverse(view_name, args=[asset.id]))
        self.assertEqual(response.status_code, 200)

    def view_access_guest_user_test(self, view_name: str):
        self.client.logout()

        # unshared, sharing disabled
        bookmark = self.setup_bookmark()
        asset = self.setup_asset_with_file(bookmark)

        response = self.client.get(reverse(view_name, args=[asset.id]))
        self.assertEqual(response.status_code, 404)

        # shared, sharing disabled
        bookmark = self.setup_bookmark(shared=True)
        asset = self.setup_asset_with_file(bookmark)

        response = self.client.get(reverse(view_name, args=[asset.id]))
        self.assertEqual(response.status_code, 404)

        # unshared, sharing enabled
        profile = self.get_or_create_test_user().profile
        profile.enable_sharing = True
        profile.save()
        bookmark = self.setup_bookmark(shared=False)
        asset = self.setup_asset_with_file(bookmark)

        response = self.client.get(reverse(view_name, args=[asset.id]))
        self.assertEqual(response.status_code, 404)

        # shared, sharing enabled
        bookmark = self.setup_bookmark(shared=True)
        asset = self.setup_asset_with_file(bookmark)

        response = self.client.get(reverse(view_name, args=[asset.id]))
        self.assertEqual(response.status_code, 404)

        # unshared, public sharing enabled
        profile.enable_public_sharing = True
        profile.save()
        bookmark = self.setup_bookmark(shared=False)
        asset = self.setup_asset_with_file(bookmark)

        response = self.client.get(reverse(view_name, args=[asset.id]))
        self.assertEqual(response.status_code, 404)

        # shared, public sharing enabled
        bookmark = self.setup_bookmark(shared=True)
        asset = self.setup_asset_with_file(bookmark)

        response = self.client.get(reverse(view_name, args=[asset.id]))
        self.assertEqual(response.status_code, 200)

    def test_view_access(self):
        self.view_access_test("linkding:assets.view")

    def test_view_access_guest_user(self):
        self.view_access_guest_user_test("linkding:assets.view")

    def test_reader_view_access(self):
        self.view_access_test("linkding:assets.read")

    def test_reader_view_access_guest_user(self):
        self.view_access_guest_user_test("linkding:assets.read")

    def test_snapshot_download_headers(self):
        bookmark = self.setup_bookmark()
        asset = self.setup_asset_with_file(bookmark)
        response = self.client.get(reverse("linkding:assets.view", args=[asset.id]))

        self.assertEqual(response["Content-Type"], asset.content_type)
        self.assertEqual(
            response["Content-Disposition"],
            f'inline; filename="{asset.display_name}.html"',
        )
        self.assertEqual(response["Content-Security-Policy"], "sandbox allow-scripts")

    def test_uploaded_file_download_headers(self):
        bookmark = self.setup_bookmark()
        asset = self.setup_asset_with_uploaded_file(bookmark)
        response = self.client.get(reverse("linkding:assets.view", args=[asset.id]))

        self.assertEqual(response["Content-Type"], asset.content_type)
        self.assertEqual(
            response["Content-Disposition"],
            f'inline; filename="{asset.display_name}"',
        )
        self.assertEqual(response["Content-Security-Policy"], "sandbox allow-scripts")

    def test_uploaded_video_download_headers(self):
        bookmark = self.setup_bookmark()
        asset = self.setup_asset_with_uploaded_file(bookmark, content_type="video/mp4")
        response = self.client.get(reverse("linkding:assets.view", args=[asset.id]))

        self.assertEqual(response["Content-Type"], asset.content_type)
        self.assertEqual(
            response["Content-Disposition"],
            f'inline; filename="{asset.display_name}"',
        )
        self.assertEqual(
            response["Content-Security-Policy"], "default-src 'none'; media-src 'self';"
        )


================================================
FILE: bookmarks/tests/test_bookmark_assets.py
================================================
import os

from django.conf import settings
from django.test import TestCase

from bookmarks.models import BookmarkAsset
from bookmarks.services import bookmarks
from bookmarks.tests.helpers import BookmarkFactoryMixin


class BookmarkAssetsTestCase(TestCase, BookmarkFactoryMixin):
    def setUp(self):
        self.setup_temp_assets_dir()

    def setup_asset_file(self, filename):
        filepath = os.path.join(settings.LD_ASSET_FOLDER, filename)
        with open(filepath, "w") as f:
            f.write("test")

    def setup_asset_with_file(self, bookmark):
        filename = f"temp_{bookmark.id}.html.gzip"
        self.setup_asset_file(filename)
        asset = self.setup_asset(bookmark=bookmark, file=filename)
        return asset

    def test_delete_bookmark_deletes_asset_file(self):
        bookmark = self.setup_bookmark()
        asset = self.setup_asset_with_file(bookmark)
        self.assertTrue(
            os.path.exists(os.path.join(settings.LD_ASSET_FOLDER, asset.file))
        )

        bookmark.delete()
        self.assertFalse(
            os.path.exists(os.path.join(settings.LD_ASSET_FOLDER, asset.file))
        )

    def test_bulk_delete_bookmarks_deletes_asset_files(self):
        bookmark1 = self.setup_bookmark()
        asset1 = self.setup_asset_with_file(bookmark1)
        bookmark2 = self.setup_bookmark()
        asset2 = self.setup_asset_with_file(bookmark2)
        bookmark3 = self.setup_bookmark()
        asset3 = self.setup_asset_with_file(bookmark3)
        self.assertTrue(
            os.path.exists(os.path.join(settings.LD_ASSET_FOLDER, asset1.file))
        )
        self.assertTrue(
            os.path.exists(os.path.join(settings.LD_ASSET_FOLDER, asset2.file))
        )
        self.assertTrue(
            os.path.exists(os.path.join(settings.LD_ASSET_FOLDER, asset3.file))
        )

        bookmarks.delete_bookmarks(
            [bookmark1.id, bookmark2.id, bookmark3.id], self.get_or_create_test_user()
        )

        self.assertFalse(
            os.path.exists(os.path.join(settings.LD_ASSET_FOLDER, asset1.file))
        )
        self.assertFalse(
            os.path.exists(os.path.join(settings.LD_ASSET_FOLDER, asset2.file))
        )
        self.assertFalse(
            os.path.exists(os.path.join(settings.LD_ASSET_FOLDER, asset3.file))
        )

    def test_save_updates_file_size(self):
        # File does not exist initially
        bookmark = self.setup_bookmark()
        asset = self.setup_asset(bookmark=bookmark, file="temp.html.gz")
        self.assertIsNone(asset.file_size)

        # Add file, save again
        self.setup_asset_file(asset.file)
        asset.save()
        self.assertEqual(asset.file_size, 4)

        # Create asset with initial file
        asset = self.setup_asset(bookmark=bookmark, file="temp.html.gz")
        self.assertEqual(asset.file_size, 4)

    def test_download_name_for_html_snapshot(self):
        bookmark = self.setup_bookmark()
        asset = self.setup_asset(
            bookmark=bookmark,
            asset_type=BookmarkAsset.TYPE_SNAPSHOT,
            content_type=BookmarkAsset.CONTENT_TYPE_HTML,
            display_name="HTML snapshot from Jan 1, 2025",
        )
        self.assertEqual(asset.download_name, "HTML snapshot from Jan 1, 2025.html")

    def test_download_name_for_pdf_snapshot(self):
        bookmark = self.setup_bookmark()
        asset = self.setup_asset(
            bookmark=bookmark,
            asset_type=BookmarkAsset.TYPE_SNAPSHOT,
            content_type=BookmarkAsset.CONTENT_TYPE_PDF,
            display_name="PDF download from Jan 1, 2025",
        )
        self.assertEqual(asset.download_name, "PDF download from Jan 1, 2025.pdf")

    def test_download_name_for_upload(self):
        bookmark = self.setup_bookmark()
        asset = self.setup_asset(
            bookmark=bookmark,
            asset_type=BookmarkAsset.TYPE_UPLOAD,
            content_type="text/plain",
            display_name="document.txt",
        )
        self.assertEqual(asset.download_name, "document.txt")


================================================
FILE: bookmarks/tests/test_bookmark_assets_api.py
================================================
import io

from django.core.files.uploadedfile import SimpleUploadedFile
from django.test import override_settings
from django.urls import reverse
from rest_framework import status

from bookmarks.models import BookmarkAsset
from bookmarks.tests.helpers import BookmarkFactoryMixin, LinkdingApiTestCase


class BookmarkAssetsApiTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
    def setUp(self):
        self.setup_temp_assets_dir()

    def assertAsset(self, asset: BookmarkAsset, data: dict):
        self.assertEqual(asset.id, data["id"])
        self.assertEqual(asset.bookmark.id, data["bookmark"])
        self.assertEqual(
            asset.date_created.isoformat().replace("+00:00", "Z"), data["date_created"]
        )
        self.assertEqual(asset.file_size, data["file_size"])
        self.assertEqual(asset.asset_type, data["asset_type"])
        self.assertEqual(asset.content_type, data["content_type"])
        self.assertEqual(asset.display_name, data["display_name"])
        self.assertEqual(asset.status, data["status"])

    def test_asset_list(self):
        self.authenticate()

        bookmark1 = self.setup_bookmark(url="https://example1.com")
        bookmark1_assets = [
            self.setup_asset(bookmark=bookmark1),
            self.setup_asset(bookmark=bookmark1),
            self.setup_asset(bookmark=bookmark1),
        ]

        bookmark2 = self.setup_bookmark(url="https://example2.com")
        bookmark2_assets = [
            self.setup_asset(bookmark=bookmark2),
            self.setup_asset(bookmark=bookmark2),
            self.setup_asset(bookmark=bookmark2),
        ]

        url = reverse(
            "linkding:bookmark_asset-list", kwargs={"bookmark_id": bookmark1.id}
        )
        response = self.get(url, expected_status_code=status.HTTP_200_OK)
        self.assertEqual(len(response.data["results"]), 3)
        self.assertAsset(bookmark1_assets[0], response.data["results"][0])
        self.assertAsset(bookmark1_assets[1], response.data["results"][1])
        self.assertAsset(bookmark1_assets[2], response.data["results"][2])

        url = reverse(
            "linkding:bookmark_asset-list", kwargs={"bookmark_id": bookmark2.id}
        )
        response = self.get(url, expected_status_code=status.HTTP_200_OK)
        self.assertEqual(len(response.data["results"]), 3)
        self.assertAsset(bookmark2_assets[0], response.data["results"][0])
        self.assertAsset(bookmark2_assets[1], response.data["results"][1])
        self.assertAsset(bookmark2_assets[2], response.data["results"][2])

    def test_asset_list_only_returns_assets_for_own_bookmarks(self):
        self.authenticate()

        other_user = self.setup_user()
        bookmark = self.setup_bookmark(user=other_user)
        self.setup_asset(bookmark=bookmark)

        url = reverse(
            "linkding:bookmark_asset-list", kwargs={"bookmark_id": bookmark.id}
        )
        self.get(url, expected_status_code=status.HTTP_404_NOT_FOUND)

    def test_asset_list_requires_authentication(self):
        bookmark = self.setup_bookmark()
        url = reverse(
            "linkding:bookmark_asset-list", kwargs={"bookmark_id": bookmark.id}
        )
        self.get(url, expected_status_code=status.HTTP_401_UNAUTHORIZED)

    def test_asset_detail(self):
        self.authenticate()

        bookmark = self.setup_bookmark()
        asset = self.setup_asset(
            bookmark=bookmark,
            asset_type=BookmarkAsset.TYPE_UPLOAD,
            file="cats.png",
            file_size=1234,
            content_type="image/png",
            display_name="cats.png",
            status=BookmarkAsset.STATUS_PENDING,
            gzip=False,
        )
        url = reverse(
            "linkding:bookmark_asset-detail",
            kwargs={"bookmark_id": asset.bookmark.id, "pk": asset.id},
        )
        response = self.get(url, expected_status_code=status.HTTP_200_OK)
        self.assertAsset(asset, response.data)

    def test_asset_detail_only_returns_asset_for_own_bookmarks(self):
        self.authenticate()

        other_user = self.setup_user()
        bookmark = self.setup_bookmark(user=other_user)
        asset = self.setup_asset(bookmark=bookmark)

        url = reverse(
            "linkding:bookmark_asset-detail",
            kwargs={"bookmark_id": asset.bookmark.id, "pk": asset.id},
        )
        self.get(url, expected_status_code=status.HTTP_404_NOT_FOUND)

    def test_asset_detail_requires_authentication(self):
        bookmark = self.setup_bookmark()
        asset = self.setup_asset(bookmark=bookmark)
        url = reverse(
            "linkding:bookmark_asset-detail",
            kwargs={"bookmark_id": asset.bookmark.id, "pk": asset.id},
        )
        self.get(url, expected_status_code=status.HTTP_401_UNAUTHORIZED)

    def test_asset_download_with_snapshot_asset(self):
        self.authenticate()

        file_content = """
            <html>
            <head>
                <title>Test</title>
            </head>
            <body>
                <h1>Test</h1>
            </body>
        """
        bookmark = self.setup_bookmark()
        asset = self.setup_asset(
            bookmark=bookmark,
            asset_type=BookmarkAsset.TYPE_SNAPSHOT,
            display_name="Snapshot from today",
            content_type="text/html",
            gzip=True,
        )
        self.setup_asset_file(asset=asset, file_content=file_content)

        url = reverse(
            "linkding:bookmark_asset-download",
            kwargs={"bookmark_id": asset.bookmark.id, "pk": asset.id},
        )
        response = self.get(url, expected_status_code=status.HTTP_200_OK)

        self.assertEqual(response["Content-Type"], "text/html")
        self.assertEqual(
            response["Content-Disposition"],
            'attachment; filename="Snapshot from today.html"',
        )
        content = b"".join(response.streaming_content).decode("utf-8")
        self.assertEqual(content, file_content)

    def test_asset_download_with_uploaded_asset(self):
        self.authenticate()

        file_content = "some file content"
        bookmark = self.setup_bookmark()
        asset = self.setup_asset(
            bookmark=bookmark,
            asset_type=BookmarkAsset.TYPE_UPLOAD,
            display_name="cats.png",
            content_type="image/png",
            gzip=False,
        )
        self.setup_asset_file(asset=asset, file_content=file_content)

        url = reverse(
            "linkding:bookmark_asset-download",
            kwargs={"bookmark_id": asset.bookmark.id, "pk": asset.id},
        )
        response = self.get(url, expected_status_code=status.HTTP_200_OK)

        self.assertEqual(response["Content-Type"], "image/png")
        self.assertEqual(
            response["Content-Disposition"],
            'attachment; filename="cats.png"',
        )
        content = b"".join(response.streaming_content).decode("utf-8")
        self.assertEqual(content, file_content)

    def test_asset_download_with_missing_file(self):
        self.authenticate()

        bookmark = self.setup_bookmark()
        asset = self.setup_asset(
            bookmark=bookmark,
            asset_type=BookmarkAsset.TYPE_UPLOAD,
            display_name="cats.png",
            content_type="image/png",
            gzip=False,
        )

        url = reverse(
            "linkding:bookmark_asset-download",
            kwargs={"bookmark_id": asset.bookmark.id, "pk": asset.id},
        )
        self.get(url, expected_status_code=status.HTTP_404_NOT_FOUND)

    def test_asset_download_only_returns_asset_for_own_bookmarks(self):
        self.authenticate()

        other_user = self.setup_user()
        bookmark = self.setup_bookmark(user=other_user)
        asset = self.setup_asset(bookmark=bookmark)

        url = reverse(
            "linkding:bookmark_asset-download",
            kwargs={"bookmark_id": asset.bookmark.id, "pk": asset.id},
        )
        self.get(url, expected_status_code=status.HTTP_404_NOT_FOUND)

    def test_asset_download_requires_authentication(self):
        bookmark = self.setup_bookmark()
        asset = self.setup_asset(bookmark=bookmark)
        url = reverse(
            "linkding:bookmark_asset-download",
            kwargs={"bookmark_id": asset.bookmark.id, "pk": asset.id},
        )
        self.get(url, expected_status_code=status.HTTP_401_UNAUTHORIZED)

    def create_upload_body(self):
        url = "https://example.com"
        file_content = b"dummy content"
        file = io.BytesIO(file_content)
        file.name = "snapshot.html"

        return {"url": url, "file": file}

    def test_upload_asset(self):
        self.authenticate()

        bookmark = self.setup_bookmark()
        url = reverse(
            "linkding:bookmark_asset-upload", kwargs={"bookmark_id": bookmark.id}
        )
        file_content = b"test file content"
        file_name = "test.txt"
        file = SimpleUploadedFile(file_name, file_content, content_type="text/plain")

        response = self.client.post(url, {"file": file}, format="multipart")
        self.assertEqual(response.status_code, status.HTTP_201_CREATED)

        asset = BookmarkAsset.objects.get(id=response.data["id"])
        self.assertEqual(asset.bookmark, bookmark)
        self.assertEqual(asset.display_name, file_name)
        self.assertEqual(asset.asset_type, BookmarkAsset.TYPE_UPLOAD)
        self.assertEqual(asset.content_type, "text/plain")
        self.assertEqual(asset.file_size, self.get_asset_filesize(asset))
        self.assertTrue(asset.gzip)

        content = self.read_asset_file(asset)
        self.assertEqual(content, file_content)

    def test_upload_asset_with_missing_file(self):
        self.authenticate()

        bookmark = self.setup_bookmark()
        url = reverse(
            "linkding:bookmark_asset-upload", kwargs={"bookmark_id": bookmark.id}
        )

        response = self.client.post(url, {}, format="multipart")
        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)

    def test_upload_asset_only_works_for_own_bookmarks(self):
        self.authenticate()

        other_user = self.setup_user()
        bookmark = self.setup_bookmark(user=other_user)
        url = reverse(
            "linkding:bookmark_asset-upload", kwargs={"bookmark_id": bookmark.id}
        )

        response = self.client.post(url, {}, format="multipart")
        self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)

    def test_upload_asset_requires_authentication(self):
        bookmark = self.setup_bookmark()
        url = reverse(
            "linkding:bookmark_asset-upload", kwargs={"bookmark_id": bookmark.id}
        )

        response = self.client.post(url, {}, format="multipart")
        self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)

    @override_settings(LD_DISABLE_ASSET_UPLOAD=True)
    def test_upload_asset_disabled(self):
        self.authenticate()
        bookmark = self.setup_bookmark()
        url = reverse(
            "linkding:bookmark_asset-upload", kwargs={"bookmark_id": bookmark.id}
        )
        response = self.client.post(url, {}, format="multipart")
        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)

    def test_delete_asset(self):
        self.authenticate()

        bookmark = self.setup_bookmark()
        asset = self.setup_asset(bookmark=bookmark)
        self.setup_asset_file(asset=asset)

        url = reverse(
            "linkding:bookmark_asset-detail",
            kwargs={"bookmark_id": asset.bookmark.id, "pk": asset.id},
        )
        self.delete(url, expected_status_code=status.HTTP_204_NO_CONTENT)

        self.assertFalse(BookmarkAsset.objects.filter(id=asset.id).exists())
        self.assertFalse(self.has_asset_file(asset))

    def test_delete_asset_only_works_for_own_bookmarks(self):
        self.authenticate()

        other_user = self.setup_user()
        bookmark = self.setup_bookmark(user=other_user)
        asset = self.setup_asset(bookmark=bookmark)

        url = reverse(
            "linkding:bookmark_asset-detail",
            kwargs={"bookmark_id": asset.bookmark.id, "pk": asset.id},
        )
        self.delete(url, expected_status_code=status.HTTP_404_NOT_FOUND)

    def test_delete_asset_requires_authentication(self):
        bookmark = self.setup_bookmark()
        asset = self.setup_asset(bookmark=bookmark)
        url = reverse(
            "linkding:bookmark_asset-detail",
            kwargs={"bookmark_id": asset.bookmark.id, "pk": asset.id},
        )
        self.delete(url, expected_status_code=status.HTTP_401_UNAUTHORIZED)


================================================
FILE: bookmarks/tests/test_bookmark_details_modal.py
================================================
import datetime
import re

from django.test import TestCase, override_settings
from django.urls import reverse
from django.utils import formats, timezone

from bookmarks.models import BookmarkAsset, UserProfile
from bookmarks.tests.helpers import BookmarkFactoryMixin, HtmlTestMixin


class BookmarkDetailsModalTestCase(TestCase, BookmarkFactoryMixin, HtmlTestMixin):
    def setUp(self):
        user = self.get_or_create_test_user()
        self.client.force_login(user)

    def get_details_form(self, soup, bookmark):
        form_url = (
            reverse("linkding:bookmarks.index.action") + f"?details={bookmark.id}"
        )
        return soup.find("form", {"action": form_url, "enctype": "multipart/form-data"})

    def get_index_details_modal(self, bookmark):
        url = reverse("linkding:bookmarks.index") + f"?details={bookmark.id}"
        response = self.client.get(url)
        soup = self.make_soup(response.content.decode())
        return soup.select_one("ld-details-modal")

    def get_shared_details_modal(self, bookmark):
        url = reverse("linkding:bookmarks.shared") + f"?details={bookmark.id}"
        response = self.client.get(url)
        soup = self.make_soup(response.content.decode())
        return soup.select_one("ld-details-modal")

    def has_details_modal(self, response):
        soup = self.make_soup(response.content.decode())
        return soup.select_one("ld-details-modal") is not None

    def find_section_content(self, soup, section_name):
        h3 = soup.find("h3", string=section_name)
        content = h3.find_next_sibling("div") if h3 else None
        return content

    def get_section_content(self, soup, section_name):
        content = self.find_section_content(soup, section_name)
        self.assertIsNotNone(content)
        return content

    def find_weblink(self, soup, url):
        return soup.find("a", {"class": "weblink", "href": url})

    def count_weblinks(self, soup):
        return len(soup.find_all("a", {"class": "weblink"}))

    def find_asset(self, soup, asset):
        return soup.find("div", {"data-asset-id": asset.id})

    def test_access(self):
        # own bookmark
        bookmark = self.setup_bookmark()
        response = self.client.get(
            reverse("linkding:bookmarks.index") + f"?details={bookmark.id}"
        )
        self.assertEqual(response.status_code, 200)
        self.assertTrue(self.has_details_modal(response))

        # other user's bookmark
        other_user = self.setup_user()
        bookmark = self.setup_bookmark(user=other_user)
        response = self.client.get(
            reverse("linkding:bookmarks.index") + f"?details={bookmark.id}"
        )
        self.assertEqual(response.status_code, 200)
        self.assertFalse(self.has_details_modal(response))

        # non-existent bookmark - just returns without modal in response
        response = self.client.get(
            reverse("linkding:bookmarks.index") + "?details=9999"
        )
        self.assertEqual(response.status_code, 200)
        self.assertFalse(self.has_details_modal(response))

        # guest user
        self.client.logout()
        response = self.client.get(
            reverse("linkding:bookmarks.shared") + f"?details={bookmark.id}"
        )
        self.assertEqual(response.status_code, 200)
        self.assertFalse(self.has_details_modal(response))

    def test_access_with_sharing(self):
        # shared bookmark, sharing disabled
        other_user = self.setup_user()
        bookmark = self.setup_bookmark(shared=True, user=other_user)

        response = self.client.get(
            reverse("linkding:bookmarks.shared") + f"?details={bookmark.id}"
        )
        self.assertEqual(response.status_code, 200)
        self.assertFalse(self.has_details_modal(response))

        # shared bookmark, sharing enabled
        profile = other_user.profile
        profile.enable_sharing = True
        profile.save()

        response = self.client.get(
            reverse("linkding:bookmarks.shared") + f"?details={bookmark.id}"
        )
        self.assertEqual(response.status_code, 200)
        self.assertTrue(self.has_details_modal(response))

        # shared bookmark, guest user, no public sharing
        self.client.logout()
        response = self.client.get(
            reverse("linkding:bookmarks.shared") + f"?details={bookmark.id}"
        )
        self.assertEqual(response.status_code, 200)
        self.assertFalse(self.has_details_modal(response))

        # shared bookmark, guest user, public sharing
        profile.enable_public_sharing = True
        profile.save()

        response = self.client.get(
            reverse("linkding:bookmarks.shared") + f"?details={bookmark.id}"
        )
        self.assertEqual(response.status_code, 200)
        self.assertTrue(self.has_details_modal(response))

    def test_displays_title(self):
        # with title
        bookmark = self.setup_bookmark(title="Test title")
        soup = self.get_index_details_modal(bookmark)

        title = soup.find("h2")
        self.assertIsNotNone(title)
        self.assertEqual(title.text.strip(), bookmark.title)

        # with URL only
        bookmark = self.setup_bookmark(title="")
        soup = self.get_index_details_modal(bookmark)

        title = soup.find("h2")
        self.assertIsNotNone(title)
        self.assertEqual(title.text.strip(), bookmark.url)

    def test_website_link(self):
        # basics
        bookmark = self.setup_bookmark()
        soup = self.get_index_details_modal(bookmark)
        link = self.find_weblink(soup, bookmark.url)
        self.assertIsNotNone(link)
        self.assertEqual(link["href"], bookmark.url)
        self.assertEqual(link.text.strip(), bookmark.url)

        # favicons disabled
        bookmark = self.setup_bookmark(favicon_file="example.png")
        soup = self.get_index_details_modal(bookmark)
        link = self.find_weblink(soup, bookmark.url)
        image = link.select_one("img")
        self.assertIsNone(image)

        # favicons enabled, no favicon
        profile = self.get_or_create_test_user().profile
        profile.enable_favicons = True
        profile.save()

        bookmark = self.setup_bookmark(favicon_file="")
        soup = self.get_index_details_modal(bookmark)
        link = self.find_weblink(soup, bookmark.url)
        image = link.select_one("img")
        self.assertIsNone(image)

        # favicons enabled, favicon present
        bookmark = self.setup_bookmark(favicon_file="example.png")
        soup = self.get_index_details_modal(bookmark)
        link = self.find_weblink(soup, bookmark.url)
        image = link.select_one("img")
        self.assertIsNotNone(image)
        self.assertEqual(image["src"], "/static/example.png")

    def test_reader_mode_link(self):
        # no latest snapshot
        bookmark = self.setup_bookmark()
        soup = self.get_index_details_modal(bookmark)
        self.assertEqual(self.count_weblinks(soup), 2)

        # snapshot is not complete
        self.setup_asset(
            bookmark,
            asset_type=BookmarkAsset.TYPE_SNAPSHOT,
            status=BookmarkAsset.STATUS_PENDING,
        )
        self.setup_asset(
            bookmark,
            asset_type=BookmarkAsset.TYPE_SNAPSHOT,
            status=BookmarkAsset.STATUS_FAILURE,
        )
        soup = self.get_index_details_modal(bookmark)
        self.assertEqual(self.count_weblinks(soup), 2)

        # not a snapshot
        self.setup_asset(
            bookmark,
            asset_type="upload",
            status=BookmarkAsset.STATUS_COMPLETE,
        )
        soup = self.get_index_details_modal(bookmark)
        self.assertEqual(self.count_weblinks(soup), 2)

        # snapshot is complete
        asset = self.setup_asset(
            bookmark,
            asset_type=BookmarkAsset.TYPE_SNAPSHOT,
            status=BookmarkAsset.STATUS_COMPLETE,
        )
        soup = self.get_index_details_modal(bookmark)
        self.assertEqual(self.count_weblinks(soup), 3)

        reader_mode_url = reverse("linkding:assets.read", args=[asset.id])
        link = self.find_weblink(soup, reader_mode_url)
        self.assertIsNotNone(link)

    def test_internet_archive_link_with_snapshot_url(self):
        bookmark = self.setup_bookmark(web_archive_snapshot_url="https://example.com/")
        soup = self.get_index_details_modal(bookmark)
        link = self.find_weblink(soup, bookmark.web_archive_snapshot_url)
        self.assertIsNotNone(link)
        self.assertEqual(link["href"], bookmark.web_archive_snapshot_url)
        self.assertEqual(link.text.strip(), "Internet Archive")

        # favicons disabled
        bookmark = self.setup_bookmark(
            web_archive_snapshot_url="https://example.com/", favicon_file="example.png"
        )
        soup = self.get_index_details_modal(bookmark)
        link = self.find_weblink(soup, bookmark.web_archive_snapshot_url)
        image = link.select_one("svg")
        self.assertIsNone(image)

        # favicons enabled, no favicon
        profile = self.get_or_create_test_user().profile
        profile.enable_favicons = True
        profile.save()

        bookmark = self.setup_bookmark(
            web_archive_snapshot_url="https://example.com/", favicon_file=""
        )
        soup = self.get_index_details_modal(bookmark)
        link = self.find_weblink(soup, bookmark.web_archive_snapshot_url)
        image = link.select_one("svg")
        self.assertIsNone(image)

        # favicons enabled, favicon present
        bookmark = self.setup_bookmark(
            web_archive_snapshot_url="https://example.com/", favicon_file="example.png"
        )
        soup = self.get_index_details_modal(bookmark)
        link = self.find_weblink(soup, bookmark.web_archive_snapshot_url)
        image = link.select_one("svg")
        self.assertIsNotNone(image)

    def test_internet_archive_link_with_fallback_url(self):
        date_added = timezone.datetime(2023, 8, 11, 21, 45, 11, tzinfo=datetime.UTC)
        bookmark = self.setup_bookmark(url="https://example.com/", added=date_added)
        fallback_web_archive_url = (
            "https://web.archive.org/web/20230811214511/https://example.com/"
        )

        soup = self.get_index_details_modal(bookmark)
        link = self.find_weblink(soup, fallback_web_archive_url)
        self.assertIsNotNone(link)
        self.assertEqual(link["href"], fallback_web_archive_url)
        self.assertEqual(link.text.strip(), "Internet Archive")

    def test_weblinks_respect_target_setting(self):
        bookmark = self.setup_bookmark(web_archive_snapshot_url="https://example.com/")

        # target blank
        profile = self.get_or_create_test_user().profile
        profile.bookmark_link_target = UserProfile.BOOKMARK_LINK_TARGET_BLANK
        profile.save()

        soup = self.get_index_details_modal(bookmark)

        website_link = self.find_weblink(soup, bookmark.url)
        self.assertIsNotNone(website_link)
        self.assertEqual(website_link["target"], UserProfile.BOOKMARK_LINK_TARGET_BLANK)

        web_archive_link = self.find_weblink(soup, bookmark.web_archive_snapshot_url)
        self.assertIsNotNone(web_archive_link)
        self.assertEqual(
            web_archive_link["target"], UserProfile.BOOKMARK_LINK_TARGET_BLANK
        )

        # target self
        profile.bookmark_link_target = UserProfile.BOOKMARK_LINK_TARGET_SELF
        profile.save()

        soup = self.get_index_details_modal(bookmark)

        website_link = self.find_weblink(soup, bookmark.url)
        self.assertIsNotNone(website_link)
        self.assertEqual(website_link["target"], UserProfile.BOOKMARK_LINK_TARGET_SELF)

        web_archive_link = self.find_weblink(soup, bookmark.web_archive_snapshot_url)
        self.assertIsNotNone(web_archive_link)
        self.assertEqual(
            web_archive_link["target"], UserProfile.BOOKMARK_LINK_TARGET_SELF
        )

    def test_preview_image(self):
        # without image
        bookmark = self.setup_bookmark()
        soup = self.get_index_details_modal(bookmark)
        image = soup.select_one("div.preview-image img")
        self.assertIsNone(image)

        # with image
        bookmark = self.setup_bookmark(preview_image_file="example.png")
        soup = self.get_index_details_modal(bookmark)
        image = soup.select_one("div.preview-image img")
        self.assertIsNone(image)

        # preview images enabled, no image
        profile = self.get_or_create_test_user().profile
        profile.enable_preview_images = True
        profile.save()

        bookmark = self.setup_bookmark()
        soup = self.get_index_details_modal(bookmark)
        image = soup.select_one("div.preview-image img")
        self.assertIsNone(image)

        # preview images enabled, image present
        bookmark = self.setup_bookmark(preview_image_file="example.png")
        soup = self.get_index_details_modal(bookmark)
        image = soup.select_one("div.preview-image img")
        self.assertIsNotNone(image)
        self.assertEqual(image["src"], "/static/example.png")

    def test_status(self):
        # renders form
        bookmark = self.setup_bookmark()
        soup = self.get_index_details_modal(bookmark)

        form = self.get_details_form(soup, bookmark)
        self.assertIsNotNone(form)
        self.assertEqual(form["method"], "post")

        # sharing disabled
        bookmark = self.setup_bookmark()
        soup = self.get_index_details_modal(bookmark)
        section = self.get_section_content(soup, "Status")

        archived = section.find("input", {"type": "checkbox", "name": "is_archived"})
        self.assertIsNotNone(archived)
        unread = section.find("input", {"type": "checkbox", "name": "unread"})
        self.assertIsNotNone(unread)
        shared = section.find("input", {"type": "checkbox", "name": "shared"})
        self.assertIsNone(shared)

        # sharing enabled
        profile = self.get_or_create_test_user().profile
        profile.enable_sharing = True
        profile.save()

        bookmark = self.setup_bookmark()
        soup = self.get_index_details_modal(bookmark)
        section = self.get_section_content(soup, "Status")

        archived = section.find("input", {"type": "checkbox", "name": "is_archived"})
        self.assertIsNotNone(archived)
        unread = section.find("input", {"type": "checkbox", "name": "unread"})
        self.assertIsNotNone(unread)
        shared = section.find("input", {"type": "checkbox", "name": "shared"})
        self.assertIsNotNone(shared)

        # unchecked
        bookmark = self.setup_bookmark()
        soup = self.get_index_details_modal(bookmark)
        section = self.get_section_content(soup, "Status")

        archived = section.find("input", {"type": "checkbox", "name": "is_archived"})
        self.assertFalse(archived.has_attr("checked"))
        unread = section.find("input", {"type": "checkbox", "name": "unread"})
        self.assertFalse(unread.has_attr("checked"))
        shared = section.find("input", {"type": "checkbox", "name": "shared"})
        self.assertFalse(shared.has_attr("checked"))

        # checked
        bookmark = self.setup_bookmark(is_archived=True, unread=True, shared=True)
        soup = self.get_index_details_modal(bookmark)
        section = self.get_section_content(soup, "Status")

        archived = section.find("input", {"type": "checkbox", "name": "is_archived"})
        self.assertTrue(archived.has_attr("checked"))
        unread = section.find("input", {"type": "checkbox", "name": "unread"})
        self.assertTrue(unread.has_attr("checked"))
        shared = section.find("input", {"type": "checkbox", "name": "shared"})
        self.assertTrue(shared.has_attr("checked"))

    def test_status_visibility(self):
        # own bookmark
        bookmark = self.setup_bookmark()
        soup = self.get_index_details_modal(bookmark)
        section = self.find_section_content(soup, "Status")
        self.assertIsNotNone(section)

        # other user's bookmark
        other_user = self.setup_user(enable_sharing=True)
        bookmark = self.setup_bookmark(user=other_user, shared=True)
        soup = self.get_shared_details_modal(bookmark)
        section = self.find_section_content(soup, "Status")
        self.assertIsNone(section)

        # guest user
        self.client.logout()
        other_user.profile.enable_public_sharing = True
        other_user.profile.save()
        bookmark = self.setup_bookmark(user=other_user, shared=True)
        soup = self.get_shared_details_modal(bookmark)
        section = self.find_section_content(soup, "Status")
        self.assertIsNone(section)

    def test_date_added(self):
        bookmark = self.setup_bookmark()
        soup = self.get_index_details_modal(bookmark)
        section = self.get_section_content(soup, "Date added")

        expected_date = formats.date_format(bookmark.date_added, "DATETIME_FORMAT")
        date = section.find("span", string=expected_date)
        self.assertIsNotNone(date)

    def test_tags(self):
        # without tags
        bookmark = self.setup_bookmark()
        soup = self.get_index_details_modal(bookmark)

        section = self.find_section_content(soup, "Tags")
        self.assertIsNone(section)

        # with tags
        bookmark = self.setup_bookmark(tags=[self.setup_tag(), self.setup_tag()])

        soup = self.get_index_details_modal(bookmark)
        section = self.get_section_content(soup, "Tags")

        for tag in bookmark.tags.all():
            tag_link = section.find("a", string=f"#{tag.name}")
            self.assertIsNotNone(tag_link)
            expected_url = reverse("linkding:bookmarks.index") + f"?q=%23{tag.name}"
            self.assertEqual(tag_link["href"], expected_url)

    def test_description(self):
        # without description
        bookmark = self.setup_bookmark(description="")
        soup = self.get_index_details_modal(bookmark)

        section = self.find_section_content(soup, "Description")
        self.assertIsNone(section)

        # with description
        bookmark = self.setup_bookmark(description="Test description")
        soup = self.get_index_details_modal(bookmark)

        section = self.get_section_content(soup, "Description")
        self.assertEqual(section.text.strip(), bookmark.description)

    def test_notes(self):
        # without notes
        bookmark = self.setup_bookmark()
        soup = self.get_index_details_modal(bookmark)

        section = self.find_section_content(soup, "Notes")
        self.assertIsNone(section)

        # with notes
        bookmark = self.setup_bookmark(notes="Test notes")
        soup = self.get_index_details_modal(bookmark)

        section = self.get_section_content(soup, "Notes")
        self.assertEqual(section.decode_contents(), "<p>Test notes</p>")

    def test_edit_link(self):
        bookmark = self.setup_bookmark()

        # with default return URL
        soup = self.get_index_details_modal(bookmark)
        edit_link = soup.find("a", string="Edit")
        self.assertIsNotNone(edit_link)
        expected_url = f"/bookmarks/{bookmark.id}/edit?return_url=/bookmarks%3Fdetails%3D{bookmark.id}"
        self.assertEqual(expected_url, edit_link["href"])

    def test_delete_button(self):
        bookmark = self.setup_bookmark()

        modal = self.get_index_details_modal(bookmark)
        delete_button = modal.find("button", {"type": "submit", "name": "remove"})
        self.assertIsNotNone(delete_button)
        self.assertEqual("Delete", delete_button.text.strip())
        self.assertEqual(str(bookmark.id), delete_button["value"])

        form = delete_button.find_parent("form")
        self.assertIsNotNone(form)
        expected_url = reverse("linkding:bookmarks.index.action")
        self.assertEqual(expected_url, form["action"])

    def test_actions_visibility(self):
        # own bookmark
        bookmark = self.setup_bookmark()

        soup = self.get_index_details_modal(bookmark)
        edit_link = soup.find("a", string="Edit")
        delete_button = soup.find("button", {"type": "submit", "name": "remove"})
        self.assertIsNotNone(edit_link)
        self.assertIsNotNone(delete_button)

        # with sharing
        other_user = self.setup_user(enable_sharing=True)
        bookmark = self.setup_bookmark(user=other_user, shared=True)

        soup = self.get_shared_details_modal(bookmark)
        edit_link = soup.find("a", string="Edit")
        delete_button = soup.find("button", {"type": "submit", "name": "remove"})
        self.assertIsNone(edit_link)
        self.assertIsNone(delete_button)

        # with public sharing
        profile = other_user.profile
        profile.enable_public_sharing = True
        profile.save()
        bookmark = self.setup_bookmark(user=other_user, shared=True)

        soup = self.get_shared_details_modal(bookmark)
        edit_link = soup.find("a", string="Edit")
        delete_button = soup.find("button", {"type": "submit", "name": "remove"})
        self.assertIsNone(edit_link)
        self.assertIsNone(delete_button)

        # guest user
        self.client.logout()
        bookmark = self.setup_bookmark(user=other_user, shared=True)

        soup = self.get_shared_details_modal(bookmark)
        edit_link = soup.find("a", string="Edit")
        delete_button = soup.find("button", {"type": "submit", "name": "remove"})
        self.assertIsNone(edit_link)
        self.assertIsNone(delete_button)

    def test_asset_list_visibility(self):
        # no assets
        bookmark = self.setup_bookmark()

        soup = self.get_index_details_modal(bookmark)
        section = self.get_section_content(soup, "Files")
        asset_list = section.find("div", {"class": "assets"})
        self.assertIsNone(asset_list)

        # with assets
        bookmark = self.setup_bookmark()
        self.setup_asset(bookmark)

        soup = self.get_index_details_modal(bookmark)
        section = self.get_section_content(soup, "Files")
        asset_list = section.find("div", {"class": "assets"})
        self.assertIsNotNone(asset_list)

    def test_asset_list(self):
        bookmark = self.setup_bookmark()
        assets = [
            self.setup_asset(bookmark),
            self.setup_asset(bookmark),
            self.setup_asset(bookmark),
        ]

        soup = self.get_index_details_modal(bookmark)
        section = self.get_section_content(soup, "Files")
        asset_list = section.find("div", {"class": "assets"})

        for asset in assets:
            asset_item = self.find_asset(asset_list, asset)
            self.assertIsNotNone(asset_item)

            asset_icon = asset_item.select_one(".list-item-icon svg")
            self.assertIsNotNone(asset_icon)

            asset_text = asset_item.select_one(".list-item-text span")
            self.assertIsNotNone(asset_text)
            self.assertIn(asset.display_name, asset_text.text)

            view_url = reverse("linkding:assets.view", args=[asset.id])
            view_link = asset_item.find("a", {"href": view_url})
            self.assertIsNotNone(view_link)

    @override_settings(LD_ENABLE_SNAPSHOTS=True)
    def test_asset_list_actions_visibility(self):
        # own bookmark
        bookmark = self.setup_bookmark()

        soup = self.get_index_details_modal(bookmark)
        create_snapshot = soup.find(
            "button", {"type": "submit", "name": "create_html_snapshot"}
        )
        upload_asset = soup.find("button", {"type": "submit", "name": "upload_asset"})
        self.assertIsNotNone(create_snapshot)
        self.assertIsNotNone(upload_asset)

        # with sharing
        other_user = self.setup_user(enable_sharing=True)
        bookmark = self.setup_bookmark(user=other_user, shared=True)

        soup = self.get_shared_details_modal(bookmark)
        create_snapshot = soup.find(
            "button", {"type": "submit", "name": "create_html_snapshot"}
        )
        upload_asset = soup.find("button", {"type": "submit", "name": "upload_asset"})
        self.assertIsNone(create_snapshot)
        self.assertIsNone(upload_asset)

        # with public sharing
        profile = other_user.profile
        profile.enable_public_sharing = True
        profile.save()

        soup = self.get_shared_details_modal(bookmark)
        create_snapshot = soup.find(
            "button", {"type": "submit", "name": "create_html_snapshot"}
        )
        upload_asset = soup.find("button", {"type": "submit", "name": "upload_asset"})
        self.assertIsNone(create_snapshot)
        self.assertIsNone(upload_asset)

        # guest user
        self.client.logout()
        bookmark = self.setup_bookmark(user=other_user, shared=True)

        soup = self.get_shared_details_modal(bookmark)
        edit_link = soup.find("a", string="Edit")
        delete_button = soup.find("button", {"type": "submit", "name": "remove"})
        self.assertIsNone(edit_link)
        self.assertIsNone(delete_button)

    def test_asset_list_actions_visibility_without_snapshots_enabled(self):
        bookmark = self.setup_bookmark()

        soup = self.get_index_details_modal(bookmark)
        create_snapshot = soup.find(
            "button", {"type": "submit", "name": "create_html_snapshot"}
        )
        upload_asset = soup.find("button", {"type": "submit", "name": "upload_asset"})
        self.assertIsNone(create_snapshot)
        self.assertIsNotNone(upload_asset)

    @override_settings(LD_DISABLE_ASSET_UPLOAD=True)
    def test_asset_list_actions_visibility_with_uploads_disabled(self):
        bookmark = self.setup_bookmark()

        soup = self.get_index_details_modal(bookmark)
        create_snapshot = soup.find(
            "button", {"type": "submit", "name": "create_html_snapshot"}
        )
        upload_asset = soup.find("button", {"type": "submit", "name": "upload_asset"})
        self.assertIsNone(create_snapshot)
        self.assertIsNone(upload_asset)

    def test_asset_without_file(self):
        bookmark = self.setup_bookmark()
        asset = self.setup_asset(bookmark)
        asset.file = ""
        asset.save()

        soup = self.get_index_details_modal(bookmark)
        asset_item = self.find_asset(soup, asset)
        view_url = reverse("linkding:assets.view", args=[asset.id])
        view_link = asset_item.find("a", {"href": view_url})
        self.assertIsNone(view_link)

    def test_asset_status(self):
        bookmark = self.setup_bookmark()
        pending_asset = self.setup_asset(bookmark, status=BookmarkAsset.STATUS_PENDING)
        failed_asset = self.setup_asset(bookmark, status=BookmarkAsset.STATUS_FAILURE)

        soup = self.get_index_details_modal(bookmark)

        asset_item = self.find_asset(soup, pending_asset)
        asset_text = asset_item.select_one(".list-item-text span")
        self.assertIn("(queued)", asset_text.text)

        asset_item = self.find_asset(soup, failed_asset)
        asset_text = asset_item.select_one(".list-item-text span")
        self.assertIn("(failed)", asset_text.text)

    def test_asset_file_size(self):
        bookmark = self.setup_bookmark()
        asset1 = self.setup_asset(bookmark, file_size=None)
        asset2 = self.setup_asset(bookmark, file_size=54639)
        asset3 = self.setup_asset(bookmark, file_size=11492020)

        soup = self.get_index_details_modal(bookmark)

        asset_item = self.find_asset(soup, asset1)
        asset_text = asset_item.select_one(".list-item-text")
        self.assertEqual(asset_text.text.strip(), asset1.display_name)

        asset_item = self.find_asset(soup, asset2)
        asset_text = asset_item.select_one(".list-item-text")
        self.assertIn("53.4\xa0KB", asset_text.text)

        asset_item = self.find_asset(soup, asset3)
        asset_text = asset_item.select_one(".list-item-text")
        self.assertIn("11.0\xa0MB", asset_text.text)

    def test_asset_actions_visibility(self):
        bookmark = self.setup_bookmark()

        # with file
        asset = self.setup_asset(bookmark)
        soup = self.get_index_details_modal(bookmark)

        asset_item = self.find_asset(soup, asset)
        view_link = asset_item.find("a", string="View")
        delete_button = asset_item.find(
            "button", {"type": "submit", "name": "remove_asset"}
        )
        self.assertIsNotNone(view_link)
        self.assertIsNotNone(delete_button)

        # without file
        asset.file = ""
        asset.save()
        soup = self.get_index_details_modal(bookmark)

        asset_item = self.find_asset(soup, asset)
        view_link = asset_item.find("a", string="View")
        delete_button = asset_item.find(
            "button", {"type": "submit", "name": "remove_asset"}
        )
        self.assertIsNone(view_link)
        self.assertIsNotNone(delete_button)

        # shared bookmark
        other_user = self.setup_user(enable_sharing=True, enable_public_sharing=True)
        bookmark = self.setup_bookmark(shared=True, user=other_user)
        asset = self.setup_asset(bookmark)
        soup = self.get_index_details_modal(bookmark)

        asset_item = self.find_asset(soup, asset)
        view_link = asset_item.find("a", string="View")
        delete_button = asset_item.find(
            "button", {"type": "submit", "name": "remove_asset"}
        )
        self.assertIsNotNone(view_link)
        self.assertIsNone(delete_button)

        # shared bookmark, guest user
        self.client.logout()
        soup = self.get_shared_details_modal(bookmark)

        asset_item = self.find_asset(soup, asset)
        view_link = asset_item.find("a", string="View")
        delete_button = asset_item.find(
            "button", {"type": "submit", "name": "remove_asset"}
        )
        self.assertIsNotNone(view_link)
        self.assertIsNone(delete_button)

    @override_settings(LD_ENABLE_SNAPSHOTS=True)
    def test_create_snapshot_is_disabled_when_having_pending_asset(self):
        bookmark = self.setup_bookmark()
        asset = self.setup_asset(bookmark, status=BookmarkAsset.STATUS_COMPLETE)

        # no pending asset
        soup = self.get_index_details_modal(bookmark)
        files_section = self.find_section_content(soup, "Files")
        create_button = files_section.find(
            "button", string=re.compile("Create HTML snapshot")
        )
        self.assertFalse(create_button.has_attr("disabled"))

        # with pending asset
        asset.status = BookmarkAsset.STATUS_PENDING
        asset.save()

        soup = self.get_index_details_modal(bookmark)
        files_section = self.find_section_content(soup, "Files")
        create_button = files_section.find(
            "button", string=re.compile("Create HTML snapshot")
        )
        self.assertTrue(create_button.has_attr("disabled"))


================================================
FILE: bookmarks/tests/test_bookmark_edit_view.py
================================================
from django.contrib.auth.models import User
from django.test import TestCase
from django.urls import reverse

from bookmarks.models import build_tag_string
from bookmarks.tests.helpers import BookmarkFactoryMixin


class BookmarkEditViewTestCase(TestCase, BookmarkFactoryMixin):
    def setUp(self) -> None:
        user = self.get_or_create_test_user()
        self.client.force_login(user)

    def create_form_data(self, overrides=None):
        if overrides is None:
            overrides = {}
        form_data = {
            "url": "http://example.com/edited",
            "tag_string": "editedtag1 editedtag2",
            "title": "edited title",
            "description": "edited description",
            "notes": "edited notes",
            "unread": False,
            "shared": False,
        }
        return {**form_data, **overrides}

    def test_should_render_successfully(self):
        bookmark = self.setup_bookmark()
        response = self.client.get(
            reverse("linkding:bookmarks.edit", args=[bookmark.id])
        )
        self.assertEqual(response.status_code, 200)

    def test_should_edit_bookmark(self):
        bookmark = self.setup_bookmark()
        form_data = self.create_form_data({"id": bookmark.id})

        self.client.post(
            reverse("linkding:bookmarks.edit", args=[bookmark.id]), form_data
        )

        bookmark.refresh_from_db()

        self.assertEqual(bookmark.owner, self.user)
        self.assertEqual(bookmark.url, form_data["url"])
        self.assertEqual(bookmark.title, form_data["title"])
        self.assertEqual(bookmark.description, form_data["description"])
        self.assertEqual(bookmark.notes, form_data["notes"])
        self.assertEqual(bookmark.unread, form_data["unread"])
        self.assertEqual(bookmark.shared, form_data["shared"])
        self.assertEqual(bookmark.tags.count(), 2)
        tags = bookmark.tags.order_by("name").all()
        self.assertEqual(tags[0].name, "editedtag1")
        self.assertEqual(tags[1].name, "editedtag2")

    def test_should_return_422_with_invalid_form(self):
        bookmark = self.setup_bookmark()
        form_data = self.create_form_data({"id": bookmark.id, "url": ""})
        response = self.client.post(
            reverse("linkding:bookmarks.edit", args=[bookmark.id]), form_data
        )
        self.assertEqual(response.status_code, 422)

    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("linkding: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("linkding: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("linkding: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("linkding: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",
            notes="edited notes",
        )

        response = self.client.get(
            reverse("linkding:bookmarks.edit", args=[bookmark.id])
        )
        html = response.content.decode()

        self.assertInHTML(
            f"""
            <input type="text" name="url" aria-invalid="false" autocomplete="off" autofocus class="form-input" required id="id_url" value="{bookmark.url}">
            """,
            html,
        )

        tag_string = build_tag_string(bookmark.tag_names, " ")
        self.assertInHTML(
            f"""
                <ld-tag-autocomplete input-id="id_tag_string" input-name="tag_string" input-value="{tag_string}"
                         input-aria-describedby="id_tag_string_help">
                </ld-tag-autocomplete>
        """,
            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(
            f"""
            <textarea name="description" cols="40" rows="3" 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" aria-describedby="id_notes_help">
                {bookmark.notes}
            </textarea>
        """,
            html,
        )

    def test_should_prevent_duplicate_urls(self):
        edited_bookmark = self.setup_bookmark(url="http://example.com/edited")
        existing_bookmark = self.setup_bookmark(url="http://example.com/existing")
        other_user_bookmark = self.setup_bookmark(
            url="http://example.com/other-user", user=User.objects.create_user("other")
        )

        # if the URL isn't modified it's not a duplicate
        form_data = self.create_form_data({"url": edited_bookmark.url})
        response = self.client.post(
            reverse("linkding:bookmarks.edit", args=[edited_bookmark.id]), form_data
        )
        self.assertEqual(response.status_code, 302)

        # if the URL is already bookmarked by another user, it's not a duplicate
        form_data = self.create_form_data({"url": other_user_bookmark.url})
        response = self.client.post(
            reverse("linkding:bookmarks.edit", args=[edited_bookmark.id]), form_data
        )
        self.assertEqual(response.status_code, 302)

        # if the URL is already bookmarked by the same user, it's a duplicate
        form_data = self.create_form_data({"url": existing_bookmark.url})
        response = self.client.post(
            reverse("linkding:bookmarks.edit", args=[edited_bookmark.id]), form_data
        )
        self.assertEqual(response.status_code, 422)
        self.assertInHTML(
            "<li>A bookmark with this URL already exists.</li>",
            response.content.decode(),
        )
        edited_bookmark.refresh_from_db()
        self.assertNotEqual(edited_bookmark.url, existing_bookmark.url)

    def test_should_prevent_duplicate_normalized_urls(self):
        self.setup_bookmark(url="https://EXAMPLE.COM/path/?z=1&a=2")

        edited_bookmark = self.setup_bookmark(url="http://different.com")

        form_data = self.create_form_data({"url": "https://example.com/path?a=2&z=1"})
        response = self.client.post(
            reverse("linkding:bookmarks.edit", args=[edited_bookmark.id]), form_data
        )

        self.assertEqual(response.status_code, 422)
        self.assertInHTML(
            "<li>A bookmark with this URL already exists.</li>",
            response.content.decode(),
        )

        edited_bookmark.refresh_from_db()
        self.assertEqual(edited_bookmark.url, "http://different.com")

    def test_should_redirect_to_return_url(self):
        bookmark = self.setup_bookmark()
        form_data = self.create_form_data()

        url = (
            reverse("linkding:bookmarks.edit", args=[bookmark.id])
            + "?return_url="
            + reverse("linkding:bookmarks.close")
        )
        response = self.client.post(url, form_data)

        self.assertRedirects(response, reverse("linkding:bookmarks.close"))

    def test_should_redirect_to_bookmark_index_by_default(self):
        bookmark = self.setup_bookmark()
        form_data = self.create_form_data()

        response = self.client.post(
            reverse("linkding:bookmarks.edit", args=[bookmark.id]), form_data
        )

        self.assertRedirects(response, reverse("linkding:bookmarks.index"))

    def test_should_not_redirect_to_external_url(self):
        bookmark = self.setup_bookmark()

        def post_with(return_url, follow=None):
            form_data = self.create_form_data()
            url = (
                reverse("linkding:bookmarks.edit", args=[bookmark.id])
                + f"?return_url={return_url}"
            )
            return self.client.post(url, form_data, follow=follow)

        response = post_with("https://example.com")
        self.assertRedirects(response, reverse("linkding:bookmarks.index"))
        response = post_with("//example.com")
        self.assertRedirects(response, reverse("linkding:bookmarks.index"))
        response = post_with("://example.com")
        self.assertRedirects(response, reverse("linkding:bookmarks.index"))

        response = post_with("/foo//example.com", follow=True)
        self.assertEqual(response.status_code, 404)

    def test_can_only_edit_own_bookmarks(self):
        other_user = User.objects.create_user(
            "otheruser", "otheruser@example.com", "password123"
        )
        bookmark = self.setup_bookmark(user=other_user)
        form_data = self.create_form_data({"id": bookmark.id})

        response = self.client.post(
            reverse("linkding:bookmarks.edit", args=[bookmark.id]), form_data
        )
        bookmark.refresh_from_db()
        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("linkding:bookmarks.edit", args=[bookmark.id])
        )
        html = response.content.decode()

        self.assertInHTML(
            """
            <div class="form-checkbox">
                <input type="checkbox" name="shared" aria-describedby="id_shared_help" id="id_shared">
                <i class="form-icon"></i>
                <label for="id_shared">Share</label>
            </div>
            """,
            html,
            count=0,
        )

        self.user.profile.enable_sharing = True
        self.user.profile.save()
        response = self.client.get(
            reverse("linkding:bookmarks.edit", args=[bookmark.id])
        )
        html = response.content.decode()

        self.assertInHTML(
            """
            <div class="form-checkbox">
                <input type="checkbox" name="shared" aria-describedby="id_shared_help" id="id_shared">
                <i class="form-icon"></i>
                <label for="id_shared">Share</label>
            </div>
            """,
            html,
            count=1,
        )

    def test_should_hide_notes_if_there_are_no_notes(self):
        bookmark = self.setup_bookmark()
        response = self.client.get(
            reverse("linkding: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("linkding:bookmarks.edit", args=[bookmark.id])
        )

        self.assertContains(response, '<details class="notes" open>', count=1)


================================================
FILE: bookmarks/tests/test_bookmark_index_view.py
================================================
import urllib.parse

from django.contrib.auth.models import User
from django.test import TestCase, override_settings
from django.urls import reverse

from bookmarks.models import BookmarkSearch, UserProfile
from bookmarks.tests.helpers import (
    BookmarkFactoryMixin,
    BookmarkListTestMixin,
    TagCloudTestMixin,
)


class BookmarkIndexViewTestCase(
    TestCase, BookmarkFactoryMixin, BookmarkListTestMixin, TagCloudTestMixin
):
    def setUp(self) -> None:
        user = self.get_or_create_test_user()
        self.client.force_login(user)

    def assertEditLink(self, response, url):
        html = response.content.decode()
        self.assertInHTML(
            f"""
            <a href="{url}">Edit</a>        
        """,
            html,
        )

    def assertBulkActionForm(self, response, url: str):
        soup = self.make_soup(response.content.decode())
        form = soup.select_one("form.bookmark-actions")
        self.assertIsNotNone(form)
        self.assertEqual(form.attrs["action"], url)

    def assertVisibleBundles(self, soup, bundles):
        bundle_list = soup.select_one("ul.bundle-menu")
        self.assertIsNotNone(bundle_list)

        list_items = bundle_list.select("li.bundle-menu-item")
        self.assertEqual(len(list_items), len(bundles))

        for index, list_item in enumerate(list_items):
            bundle = bundles[index]
            link = list_item.select_one("a")
            href = link.attrs["href"]

            self.assertEqual(bundle.name, list_item.text.strip())
            self.assertEqual(f"?bundle={bundle.id}", href)

    def test_should_list_unarchived_and_user_owned_bookmarks(self):
        other_user = User.objects.create_user(
            "otheruser", "otheruser@example.com", "password123"
        )
        visible_bookmarks = self.setup_numbered_bookmarks(3)
        invisible_bookmarks = [
            self.setup_bookmark(is_archived=True),
            self.setup_bookmark(user=other_user),
        ]

        response = self.client.get(reverse("linkding:bookmarks.index"))

        self.assertVisibleBookmarks(response, visible_bookmarks)
        self.assertInvisibleBookmarks(response, invisible_bookmarks)

    def test_should_list_bookmarks_matching_query(self):
        visible_bookmarks = self.setup_numbered_bookmarks(3, prefix="foo")
        invisible_bookmarks = self.setup_numbered_bookmarks(3, prefix="bar")

        response = self.client.get(reverse("linkding:bookmarks.index") + "?q=foo")

        self.assertVisibleBookmarks(response, visible_bookmarks)
        self.assertInvisibleBookmarks(response, invisible_bookmarks)

    def test_should_list_bookmarks_matching_bundle(self):
        visible_bookmarks = self.setup_numbered_bookmarks(3, prefix="foo")
        invisible_bookmarks = self.setup_numbered_bookmarks(3, prefix="bar")

        bundle = self.setup_bundle(search="foo")

        response = self.client.get(
            reverse("linkding:bookmarks.index") + f"?bundle={bundle.id}"
        )

        self.assertVisibleBookmarks(response, visible_bookmarks)
        self.assertInvisibleBookmarks(response, invisible_bookmarks)

    def test_should_list_tags_for_unarchived_and_user_owned_bookmarks(self):
        other_user = User.objects.create_user(
            "otheruser", "otheruser@example.com", "password123"
        )
        visible_bookmarks = self.setup_numbered_bookmarks(3, with_tags=True)
        archived_bookmarks = self.setup_numbered_bookmarks(
            3, with_tags=True, archived=True, tag_prefix="archived"
        )
        other_user_bookmarks = self.setup_numbered_bookmarks(
            3, with_tags=True, user=other_user, tag_prefix="otheruser"
        )

        visible_tags = self.get_tags_from_bookmarks(visible_bookmarks)
        invisible_tags = self.get_tags_from_bookmarks(
            archived_bookmarks + other_user_bookmarks
        )

        response = self.client.get(reverse("linkding:bookmarks.index"))

        self.assertVisibleTags(response, visible_tags)
        self.assertInvisibleTags(response, invisible_tags)

    def test_should_list_tags_for_bookmarks_matching_query(self):
        visible_bookmarks = self.setup_numbered_bookmarks(
            3, with_tags=True, prefix="foo", tag_prefix="foo"
        )
        invisible_bookmarks = self.setup_numbered_bookmarks(
            3, with_tags=True, prefix="bar", tag_prefix="bar"
        )

        visible_tags = self.get_tags_from_bookmarks(visible_bookmarks)
        invisible_tags = self.get_tags_from_bookmarks(invisible_bookmarks)

        response = self.client.get(reverse("linkding:bookmarks.index") + "?q=foo")

        self.assertVisibleTags(response, visible_tags)
        self.assertInvisibleTags(response, invisible_tags)

    def test_should_list_tags_for_bookmarks_matching_bundle(self):
        visible_bookmarks = self.setup_numbered_bookmarks(
            3, with_tags=True, prefix="foo", tag_prefix="foo"
        )
        invisible_bookmarks = self.setup_numbered_bookmarks(
            3, with_tags=True, prefix="bar", tag_prefix="bar"
        )

        visible_tags = self.get_tags_from_bookmarks(visible_bookmarks)
        invisible_tags = self.get_tags_from_bookmarks(invisible_bookmarks)

        bundle = self.setup_bundle(search="foo")

        response = self.client.get(
            reverse("linkding:bookmarks.index") + f"?bundle={bundle.id}"
        )

        self.assertVisibleTags(response, visible_tags)
        self.assertInvisibleTags(response, invisible_tags)

    def test_should_list_bookmarks_and_tags_for_search_preferences(self):
        user_profile = self.user.profile
        user_profile.search_preferences = {
            "unread": BookmarkSearch.FILTER_UNREAD_YES,
        }
        user_profile.save()

        unread_bookmarks = self.setup_numbered_bookmarks(
            3, unread=True, with_tags=True, prefix="unread", tag_prefix="unread"
        )
        read_bookmarks = self.setup_numbered_bookmarks(
            3, unread=False, with_tags=True, prefix="read", tag_prefix="read"
        )

        unread_tags = self.get_tags_from_bookmarks(unread_bookmarks)
        read_tags = self.get_tags_from_bookmarks(read_bookmarks)

        response = self.client.get(reverse("linkding:bookmarks.index"))
        self.assertVisibleBookmarks(response, unread_bookmarks)
        self.assertInvisibleBookmarks(response, read_bookmarks)
        self.assertVisibleTags(response, unread_tags)
        self.assertInvisibleTags(response, read_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("linkding: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("linkding: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("linkding: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_numbered_bookmarks(3)

        response = self.client.get(reverse("linkding:bookmarks.index"))

        self.assertVisibleBookmarks(response, visible_bookmarks, "_blank")

    def test_should_open_bookmarks_in_same_page_if_specified_in_user_profile(self):
        user = self.get_or_create_test_user()
        user.profile.bookmark_link_target = UserProfile.BOOKMARK_LINK_TARGET_SELF
        user.profile.save()

        visible_bookmarks = self.setup_numbered_bookmarks(3)

        response = self.client.get(reverse("linkding:bookmarks.index"))

        self.assertVisibleBookmarks(response, visible_bookmarks, "_self")

    def test_edit_link_return_url_respects_search_options(self):
        bookmark = self.setup_bookmark(title="foo")
        edit_url = reverse("linkding:bookmarks.edit", args=[bookmark.id])
        base_url = reverse("linkding:bookmarks.index")

        # without query params
        return_url = urllib.parse.quote(base_url)
        url = f"{edit_url}?return_url={return_url}"

        response = self.client.get(base_url)
        self.assertEditLink(response, url)

        # with query
        url_params = "?q=foo"
        return_url = urllib.parse.quote(base_url + url_params)
        url = f"{edit_url}?return_url={return_url}"

        response = self.client.get(base_url + url_params)
        self.assertEditLink(response, url)

        # with query and sort and page
        url_params = "?q=foo&sort=title_asc&page=2"
        return_url = urllib.parse.quote(base_url + url_params)
        url = f"{edit_url}?return_url={return_url}"

        response = self.client.get(base_url + url_params)
        self.assertEditLink(response, url)

    def test_bulk_edit_respects_search_options(self):
        action_url = reverse("linkding:bookmarks.index.action")
        base_url = reverse("linkding:bookmarks.index")

        # without params
        url = f"{action_url}"

        response = self.client.get(base_url)
        self.assertBulkActionForm(response, url)

        # with query
        url_params = "?q=foo"
        url = f"{action_url}?q=foo"

        response = self.client.get(base_url + url_params)
        self.assertBulkActionForm(response, url)

        # with query and sort
        url_params = "?q=foo&sort=title_asc"
        url = f"{action_url}?q=foo&sort=title_asc"

        response = self.client.get(base_url + url_params)
        self.assertBulkActionForm(response, url)

    def test_allowed_bulk_actions(self):
        url = reverse("linkding:bookmarks.index")
        response = self.client.get(url)
        html = response.content.decode()

        self.assertInHTML(
            """
          <select name="bulk_action" class="form-select select-sm">
            <option value="bulk_archive">Archive</option>
            <option value="bulk_delete">Delete</option>
            <option value="bulk_tag">Add tags</option>
            <option value="bulk_untag">Remove tags</option>
            <option value="bulk_read">Mark as read</option>
            <option value="bulk_unread">Mark as unread</option>
            <option value="bulk_refresh">Refresh from website</option>
          </select>
        """,
            html,
        )

    @override_settings(LD_ENABLE_SNAPSHOTS=True)
    def test_allowed_bulk_actions_with_html_snapshot_enabled(self):
        url = reverse("linkding:bookmarks.index")
        response = self.client.get(url)
        html = response.content.decode()

        self.assertInHTML(
            """
          <select name="bulk_action" class="form-select select-sm">
            <option value="bulk_archive">Archive</option>
            <option value="bulk_delete">Delete</option>
            <option value="bulk_tag">Add tags</option>
            <option value="bulk_untag">Remove tags</option>
            <option value="bulk_read">Mark as read</option>
            <option value="bulk_unread">Mark as unread</option>
            <option value="bulk_refresh">Refresh from website</option>
            <option value="bulk_snapshot">Create HTML snapshot</option>
          </select>
        """,
            html,
        )

    def test_allowed_bulk_actions_with_sharing_enabled(self):
        user_profile = self.user.profile
        user_profile.enable_sharing = True
        user_profile.save()

        url = reverse("linkding:bookmarks.index")
        response = self.client.get(url)
        html = response.content.decode()

        self.assertInHTML(
            """
          <select name="bulk_action" class="form-select select-sm">
            <option value="bulk_archive">Archive</option>
            <option value="bulk_delete">Delete</option>
            <option value="bulk_tag">Add tags</option>
            <option value="bulk_untag">Remove tags</option>
            <option value="bulk_read">Mark as read</option>
            <option value="bulk_unread">Mark as unread</option>
            <option value="bulk_share">Share</option>
            <option value="bulk_unshare">Unshare</option>
            <option value="bulk_refresh">Refresh from website</option>
          </select>
        """,
            html,
        )

    @override_settings(LD_ENABLE_SNAPSHOTS=True)
    def test_allowed_bulk_actions_with_sharing_and_html_snapshot_enabled(self):
        user_profile = self.user.profile
        user_profile.enable_sharing = True
        user_profile.save()

        url = reverse("linkding:bookmarks.index")
        response = self.client.get(url)
        html = response.content.decode()

        self.assertInHTML(
            """
          <select name="bulk_action" class="form-select select-sm">
            <option value="bulk_archive">Archive</option>
            <option value="bulk_delete">Delete</option>
            <option value="bulk_tag">Add tags</option>
            <option value="bulk_untag">Remove tags</option>
            <option value="bulk_read">Mark as read</option>
            <option value="bulk_unread">Mark as unread</option>
            <option value="bulk_share">Share</option>
            <option value="bulk_unshare">Unshare</option>
            <option value="bulk_refresh">Refresh from website</option>
            <option value="bulk_snapshot">Create HTML snapshot</option>
          </select>
        """,
            html,
        )

    def test_apply_search_preferences(self):
        # no params
        response = self.client.post(reverse("linkding:bookmarks.index"))
        self.assertEqual(response.status_code, 302)
        self.assertEqual(response.url, reverse("linkding:bookmarks.index"))

        # some params
        response = self.client.post(
            reverse("linkding:bookmarks.index"),
            {
                "q": "foo",
                "sort": BookmarkSearch.SORT_TITLE_ASC,
            },
        )
        self.assertEqual(response.status_code, 302)
        self.assertEqual(
            response.url, reverse("linkding:bookmarks.index") + "?q=foo&sort=title_asc"
        )

        # params with default value are removed
        response = self.client.post(
            reverse("linkding:bookmarks.index"),
            {
                "q": "foo",
                "user": "",
                "sort": BookmarkSearch.SORT_ADDED_DESC,
                "shared": BookmarkSearch.FILTER_SHARED_OFF,
                "unread": BookmarkSearch.FILTER_UNREAD_YES,
            },
        )
        self.assertEqual(response.status_code, 302)
        self.assertEqual(
            response.url, reverse("linkding:bookmarks.index") + "?q=foo&unread=yes"
        )

        # page is removed
        response = self.client.post(
            reverse("linkding:bookmarks.index"),
            {
                "q": "foo",
                "page": "2",
                "sort": BookmarkSearch.SORT_TITLE_ASC,
            },
        )
        self.assertEqual(response.status_code, 302)
        self.assertEqual(
            response.url, reverse("linkding:bookmarks.index") + "?q=foo&sort=title_asc"
        )

    def test_save_search_preferences(self):
        user_profile = self.user.profile

        # no params
        self.client.post(
            reverse("linkding:bookmarks.index"),
            {
                "save": "",
            },
        )
        user_profile.refresh_from_db()
        self.assertEqual(
            user_profile.search_preferences,
            {
                "sort": BookmarkSearch.SORT_ADDED_DESC,
                "shared": BookmarkSearch.FILTER_SHARED_OFF,
                "unread": BookmarkSearch.FILTER_UNREAD_OFF,
            },
        )

        # with param
        self.client.post(
            reverse("linkding:bookmarks.index"),
            {
                "save": "",
                "sort": BookmarkSearch.SORT_TITLE_ASC,
            },
        )
        user_profile.refresh_from_db()
        self.assertEqual(
            user_profile.search_preferences,
            {
                "sort": BookmarkSearch.SORT_TITLE_ASC,
                "shared": BookmarkSearch.FILTER_SHARED_OFF,
                "unread": BookmarkSearch.FILTER_UNREAD_OFF,
            },
        )

        # add a param
        self.client.post(
            reverse("linkding:bookmarks.index"),
            {
                "save": "",
                "sort": BookmarkSearch.SORT_TITLE_ASC,
                "unread": BookmarkSearch.FILTER_UNREAD_YES,
            },
        )
        user_profile.refresh_from_db()
        self.assertEqual(
            user_profile.search_preferences,
            {
                "sort": BookmarkSearch.SORT_TITLE_ASC,
                "shared": BookmarkSearch.FILTER_SHARED_OFF,
                "unread": BookmarkSearch.FILTER_UNREAD_YES,
            },
        )

        # remove a param
        self.client.post(
            reverse("linkding:bookmarks.index"),
            {
                "save": "",
                "unread": BookmarkSearch.FILTER_UNREAD_YES,
            },
        )
        user_profile.refresh_from_db()
        self.assertEqual(
            user_profile.search_preferences,
            {
                "sort": BookmarkSearch.SORT_ADDED_DESC,
                "shared": BookmarkSearch.FILTER_SHARED_OFF,
                "unread": BookmarkSearch.FILTER_UNREAD_YES,
            },
        )

        # ignores non-preferences
        self.client.post(
            reverse("linkding:bookmarks.index"),
            {
                "save": "",
                "q": "foo",
                "user": "john",
                "page": "3",
                "sort": BookmarkSearch.SORT_TITLE_ASC,
            },
        )
        user_profile.refresh_from_db()
        self.assertEqual(
            user_profile.search_preferences,
            {
                "sort": BookmarkSearch.SORT_TITLE_ASC,
                "shared": BookmarkSearch.FILTER_SHARED_OFF,
                "unread": BookmarkSearch.FILTER_UNREAD_OFF,
            },
        )

    def test_url_encode_bookmark_actions_url(self):
        url = reverse("linkding:bookmarks.index") + "?q=%23foo"
        response = self.client.get(url)
        html = response.content.decode()
        soup = self.make_soup(html)
        actions_form = soup.select("form.bookmark-actions")[0]

        self.assertEqual(
            actions_form.attrs["action"],
            "/bookmarks/action?q=%23foo",
        )

    def test_encode_search_params(self):
        bookmark = self.setup_bookmark(description="alert('xss')")

        url = reverse("linkding:bookmarks.index") + "?q=alert(%27xss%27)"
        response = self.client.get(url)
        self.assertNotContains(response, "alert('xss')")
        self.assertContains(response, bookmark.url)

        url = reverse("linkding:bookmarks.index") + "?sort=alert(%27xss%27)"
        response = self.client.get(url)
        self.assertNotContains(response, "alert('xss')")

        url = reverse("linkding:bookmarks.index") + "?unread=alert(%27xss%27)"
        response = self.client.get(url)
        self.assertNotContains(response, "alert('xss')")

        url = reverse("linkding:bookmarks.index") + "?shared=alert(%27xss%27)"
        response = self.client.get(url)
        self.assertNotContains(response, "alert('xss')")

        url = reverse("linkding:bookmarks.index") + "?user=alert(%27xss%27)"
        response = self.client.get(url)
        self.assertNotContains(response, "alert('xss')")

        url = reverse("linkding:bookmarks.index") + "?page=alert(%27xss%27)"
        response = self.client.get(url)
        self.assertNotContains(response, "alert('xss')")

    def test_turbo_frame_details_modal_renders_details_modal_update(self):
        bookmark = self.setup_bookmark()
        url = reverse("linkding:bookmarks.index") + f"?bookmark_id={bookmark.id}"
        response = self.client.get(url, headers={"Turbo-Frame": "details-modal"})

        self.assertEqual(200, response.status_code)

        soup = self.make_soup(response.content.decode())
        self.assertIsNotNone(soup.select_one("turbo-frame#details-modal"))
        self.assertIsNone(soup.select_one("#bookmark-list-container"))
        self.assertIsNone(soup.select_one("#tag-cloud-container"))

    def test_does_not_include_rss_feed(self):
        response = self.client.get(reverse("linkding:bookmarks.index"))
        soup = self.make_soup(response.content.decode())

        feed = soup.select_one('head link[type="application/rss+xml"]')
        self.assertIsNone(feed)

    def test_list_bundles(self):
        books = self.setup_bundle(name="Books bundle", order=3)
        music = self.setup_bundle(name="Music bundle", order=1)
        tools = self.setup_bundle(name="Tools bundle", order=2)
        response = self.client.get(reverse("linkding:bookmarks.index"))
        html = response.content.decode()
        soup = self.make_soup(html)

        self.assertVisibleBundles(soup, [music, tools, books])

    def test_list_bundles_only_shows_user_owned_bundles(self):
        user_bundles = [self.setup_bundle(), self.setup_bundle(), self.setup_bundle()]
        other_user = self.setup_user()
        self.setup_bundle(user=other_user)
        self.setup_bundle(user=other_user)
        self.setup_bundle(user=other_user)

        response = self.client.get(reverse("linkding:bookmarks.index"))
        html = response.content.decode()
        soup = self.make_soup(html)

        self.assertVisibleBundles(soup, user_bundles)

    def test_hide_bundles_when_enabled_in_profile(self):
        # visible by default
        response = self.client.get(reverse("linkding:bookmarks.index"))
        html = response.content.decode()

        self.assertInHTML('<h2 id="bundles-heading">Bundles</h2>', html)

        # hidden when disabled in profile
        user_profile = self.get_or_create_test_user().profile
        user_profile.hide_bundles = True
        user_profile.save()

        response = self.client.get(reverse("linkding:bookmarks.index"))
        html = response.content.decode()

        self.assertInHTML('<h2 id="bundles-heading">Bundles</h2>', html, count=0)


================================================
FILE: bookmarks/tests/test_bookmark_index_view_performance.py
================================================
from django.db import connections
from django.db.utils import DEFAULT_DB_ALIAS
from django.test import TransactionTestCase
from django.test.utils import CaptureQueriesContext
from django.urls import reverse

from bookmarks.models import GlobalSettings
from bookmarks.tests.helpers import BookmarkFactoryMixin, HtmlTestMixin


class BookmarkIndexViewPerformanceTestCase(
    TransactionTestCase, BookmarkFactoryMixin, HtmlTestMixin
):
    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 global settings
        GlobalSettings.get()

        # create initial bookmarks
        num_initial_bookmarks = 10
        for _ 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("linkding:bookmarks.index"))
            html = response.content.decode("utf-8")
            soup = self.make_soup(html)
            list_items = soup.select("ul.bookmark-list > li")
            self.assertEqual(len(list_items), num_initial_bookmarks)

        number_of_queries = context.final_queries

        # add more bookmarks
        num_additional_bookmarks = 10
        for _ 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("linkding:bookmarks.index"))
            html = response.content.decode("utf-8")
            soup = self.make_soup(html)
            list_items = soup.select("ul.bookmark-list > li")
            self.assertEqual(
                len(list_items), num_initial_bookmarks + num_additional_bookmarks
            )


================================================
FILE: bookmarks/tests/test_bookmark_new_view.py
================================================
from django.test import TestCase
from django.urls import reverse

from bookmarks.models import Bookmark
from bookmarks.tests.helpers import BookmarkFactoryMixin


class BookmarkNewViewTestCase(TestCase, BookmarkFactoryMixin):
    def setUp(self) -> None:
        user = self.get_or_create_test_user()
        self.client.force_login(user)

    def create_form_data(self, overrides=None):
        if overrides is None:
            overrides = {}
        form_data = {
            "url": "http://example.com",
            "tag_string": "tag1 tag2",
            "title": "test title",
            "description": "test description",
            "notes": "test notes",
            "unread": False,
            "shared": False,
            "auto_close": "",
        }
        return {**form_data, **overrides}

    def test_should_create_new_bookmark(self):
        form_data = self.create_form_data()

        self.client.post(reverse("linkding:bookmarks.new"), form_data)

        self.assertEqual(Bookmark.objects.count(), 1)

        bookmark = Bookmark.objects.first()
        self.assertEqual(bookmark.owner, self.user)
        self.assertEqual(bookmark.url, form_data["url"])
        self.assertEqual(bookmark.title, form_data["title"])
        self.assertEqual(bookmark.description, form_data["description"])
        self.assertEqual(bookmark.notes, form_data["notes"])
        self.assertEqual(bookmark.unread, form_data["unread"])
        self.assertEqual(bookmark.shared, form_data["shared"])
        self.assertEqual(bookmark.tags.count(), 2)
        tags = bookmark.tags.order_by("name").all()
        self.assertEqual(tags[0].name, "tag1")
        self.assertEqual(tags[1].name, "tag2")

    def test_should_return_422_with_invalid_form(self):
        form_data = self.create_form_data({"url": ""})
        response = self.client.post(reverse("linkding:bookmarks.new"), form_data)
        self.assertEqual(response.status_code, 422)

    def test_should_create_new_unread_bookmark(self):
        form_data = self.create_form_data({"unread": True})

        self.client.post(reverse("linkding: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("linkding: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("linkding:bookmarks.new") + "?url=http://example.com"
        )
        html = response.content.decode()

        self.assertInHTML(
            """
            <input type="text" name="url" aria-invalid="false" autocomplete="off" autofocus class="form-input" required id="id_url" value="http://example.com">
            """,
            html,
        )

    def test_should_prefill_title_from_url_parameter(self):
        response = self.client.get(
            reverse("linkding: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("linkding:bookmarks.new")
            + "?description=Example%20Site%20Description"
        )
        html = response.content.decode()

        self.assertInHTML(
            '<textarea name="description" class="form-input" cols="40" '
            'rows="3" id="id_description">Example Site Description</textarea>',
            html,
        )

    def test_should_prefill_tags_from_url_parameter(self):
        response = self.client.get(
            reverse("linkding:bookmarks.new") + "?tags=tag1%20tag2%20tag3"
        )
        html = response.content.decode()

        self.assertInHTML(
            """
                <ld-tag-autocomplete input-id="id_tag_string" input-name="tag_string" input-value="tag1 tag2 tag3"
                         input-aria-describedby="id_tag_string_help">
                </ld-tag-autocomplete>
            """,
            html,
        )

    def test_should_prefill_notes_from_url_parameter(self):
        response = self.client.get(
            reverse("linkding:bookmarks.new")
            + "?notes=%2A%2AFind%2A%2A%20more%20info%20%5Bhere%5D%28http%3A%2F%2Fexample.com%29"
        )
        html = response.content.decode()

        self.assertInHTML(
            """
            <details class="notes" open="">
                <summary>
                    <span class="form-label d-inline-block">Notes</span>
                </summary>
                <label for="id_notes" class="text-assistive">Notes</label>
                <textarea name="notes" cols="40" rows="8" class="form-input" id="id_notes" aria-describedby="id_notes_help">**Find** more info [here](http://example.com)</textarea>
                <div id="id_notes_help" class="form-input-hint">
                    Additional notes, supports Markdown.
                </div>
            </details>
            """,
            html,
        )

    def test_should_enable_auto_close_when_specified_in_url_parameter(self):
        response = self.client.get(reverse("linkding:bookmarks.new") + "?auto_close")
        html = response.content.decode()

        self.assertInHTML(
            '<input type="hidden" name="auto_close" value="True" id="id_auto_close">',
            html,
        )

    def test_should_not_enable_auto_close_when_not_specified_in_url_parameter(self):
        response = self.client.get(reverse("linkding:bookmarks.new"))
        html = response.content.decode()

        self.assertInHTML(
            '<input type="hidden" name="auto_close" value="False" id="id_auto_close">',
            html,
        )

    def test_should_redirect_to_index_view(self):
        form_data = self.create_form_data()

        response = self.client.post(reverse("linkding:bookmarks.new"), form_data)

        self.assertRedirects(response, reverse("linkding:bookmarks.index"))

    def test_should_not_redirect_to_external_url(self):
        form_data = self.create_form_data()

        response = self.client.post(
            reverse("linkding:bookmarks.new") + "?return_url=https://example.com",
            form_data,
        )

        self.assertRedirects(response, reverse("linkding:bookmarks.index"))

    def test_auto_close_should_redirect_to_close_view(self):
        form_data = self.create_form_data({"auto_close": "True"})

        response = self.client.post(reverse("linkding:bookmarks.new"), form_data)

        self.assertRedirects(response, reverse("linkding: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("linkding:bookmarks.new"))
        html = response.content.decode()

        self.assertInHTML(
            """
            <div class="form-checkbox">
                <input type="checkbox" name="shared" aria-describedby="id_shared_help" id="id_shared">
                <i class="form-icon"></i>
                <label for="id_shared">Share</label>
            </div>          
            """,
            html,
            count=0,
        )

        self.user.profile.enable_sharing = True
        self.user.profile.save()
        response = self.client.get(reverse("linkding:bookmarks.new"))
        html = response.content.decode()

        self.assertInHTML(
            """
            <div class="form-checkbox">
                <input type="checkbox" name="shared" aria-describedby="id_shared_help" id="id_shared">
                <i class="form-icon"></i>
                <label for="id_shared">Share</label>
            </div>              
            """,
            html,
            count=1,
        )

    def test_should_show_respective_share_hint(self):
        self.user.profile.enable_sharing = True
        self.user.profile.save()

        response = self.client.get(reverse("linkding:bookmarks.new"))
        html = response.content.decode()
        self.assertInHTML(
            """
              <div id="id_shared_help" class="form-input-hint">
                  Share this bookmark with other registered users.
              </div>
            """,
            html,
        )

        self.user.profile.enable_public_sharing = True
        self.user.profile.save()

        response = self.client.get(reverse("linkding:bookmarks.new"))
        html = response.content.decode()
        self.assertInHTML(
            """
              <div id="id_shared_help" class="form-input-hint">
                  Share this bookmark with other registered users and anonymous users.
              </div>
            """,
            html,
        )

    def test_should_hide_notes_if_there_are_no_notes(self):
        bookmark = self.setup_bookmark()
        response = self.client.get(
            reverse("linkding:bookmarks.edit", args=[bookmark.id])
        )

        self.assertContains(response, '<details class="notes">', count=1)

    def test_should_not_check_unread_by_default(self):
        response = self.client.get(reverse("linkding:bookmarks.new"))
        html = response.content.decode()

        self.assertInHTML(
            '<input type="checkbox" name="unread" id="id_unread" aria-describedby="id_unread_help">',
            html,
        )

    def test_should_check_unread_when_configured_in_profile(self):
        self.user.profile.default_mark_unread = True
        self.user.profile.save()

        response = self.client.get(reverse("linkding:bookmarks.new"))
        html = response.content.decode()

        self.assertInHTML(
            '<input type="checkbox" name="unread" id="id_unread" checked="" aria-describedby="id_unread_help">',
            html,
        )

    def test_should_not_check_shared_by_default(self):
        self.user.profile.enable_sharing = True
        self.user.profile.save()

        response = self.client.get(reverse("linkding:bookmarks.new"))
        html = response.content.decode()

        self.assertInHTML(
            '<input type="checkbox" name="shared" id="id_shared" aria-describedby="id_shared_help">',
            html,
        )

    def test_should_check_shared_when_configured_in_profile(self):
        self.user.profile.enable_sharing = True
        self.user.profile.default_mark_shared = True
        self.user.profile.save()

        response = self.client.get(reverse("linkding:bookmarks.new"))
        html = response.content.decode()

        self.assertInHTML(
            '<input type="checkbox" name="shared" id="id_shared" checked="" aria-describedby="id_shared_help">',
            html,
        )


================================================
FILE: bookmarks/tests/test_bookmark_previews.py
================================================
import os
import shutil
import tempfile

from django.conf import settings
from django.test import TestCase, override_settings

from bookmarks.services import bookmarks
from bookmarks.tests.helpers import BookmarkFactoryMixin


class BookmarkPreviewsTestCase(TestCase, BookmarkFactoryMixin):
    def setUp(self):
        self.temp_dir = tempfile.mkdtemp()
        self.override = override_settings(LD_PREVIEW_FOLDER=self.temp_dir)
        self.override.enable()

    def tearDown(self):
        self.override.disable()
        shutil.rmtree(self.temp_dir)

    def setup_preview_file(self, filename):
        filepath = os.path.join(settings.LD_PREVIEW_FOLDER, filename)
        with open(filepath, "w") as f:
            f.write("test")

    def setup_bookmark_with_preview(self):
        bookmark = self.setup_bookmark()
        bookmark.preview_image_file = f"preview_{bookmark.id}.jpg"
        bookmark.save()
        self.setup_preview_file(bookmark.preview_image_file)
        return bookmark

    def assertPreviewImageExists(self, bookmark):
        self.assertTrue(
            os.path.exists(
                os.path.join(settings.LD_PREVIEW_FOLDER, bookmark.preview_image_file)
            )
        )

    def assertPreviewImageDoesNotExist(self, bookmark):
        self.assertFalse(
            os.path.exists(
                os.path.join(settings.LD_PREVIEW_FOLDER, bookmark.preview_image_file)
            )
        )

    def test_delete_bookmark_deletes_preview_image(self):
        bookmark = self.setup_bookmark_with_preview()
        self.assertPreviewImageExists(bookmark)

        bookmark.delete()
        self.assertPreviewImageDoesNotExist(bookmark)

    def test_bulk_delete_bookmarks_deletes_preview_images(self):
        bookmark1 = self.setup_bookmark_with_preview()
        bookmark2 = self.setup_bookmark_with_preview()
        bookmark3 = self.setup_bookmark_with_preview()

        self.assertPreviewImageExists(bookmark1)
        self.assertPreviewImageExists(bookmark2)
        self.assertPreviewImageExists(bookmark3)

        bookmarks.delete_bookmarks(
            [bookmark1.id, bookmark2.id, bookmark3.id], self.get_or_create_test_user()
        )

        self.assertPreviewImageDoesNotExist(bookmark1)
        self.assertPreviewImageDoesNotExist(bookmark2)
        self.assertPreviewImageDoesNotExist(bookmark3)


================================================
FILE: bookmarks/tests/test_bookmark_search_form.py
================================================
from django.test import TestCase

from bookmarks.forms import BookmarkSearchForm
from bookmarks.models import BookmarkSearch
from bookmarks.tests.helpers import BookmarkFactoryMixin


class BookmarkSearchFormTest(TestCase, BookmarkFactoryMixin):
    def test_initial_values(self):
        # no params
        search = BookmarkSearch()
        form = BookmarkSearchForm(search)
        self.assertEqual(form["q"].initial, "")
        self.assertEqual(form["user"].initial, "")
        self.assertEqual(form["bundle"].initial, None)
        self.assertEqual(form["sort"].initial, BookmarkSearch.SORT_ADDED_DESC)
        self.assertEqual(form["shared"].initial, BookmarkSearch.FILTER_SHARED_OFF)
        self.assertEqual(form["unread"].initial, BookmarkSearch.FILTER_UNREAD_OFF)

        # with params
        bundle = self.setup_bundle()
        search = BookmarkSearch(
            q="search query",
            sort=BookmarkSearch.SORT_ADDED_ASC,
            user="user123",
            bundle=bundle,
            shared=BookmarkSearch.FILTER_SHARED_SHARED,
            unread=BookmarkSearch.FILTER_UNREAD_YES,
        )
        form = BookmarkSearchForm(search)
        self.assertEqual(form["q"].initial, "search query")
        self.assertEqual(form["user"].initial, "user123")
        self.assertEqual(form["bundle"].initial, bundle.id)
        self.assertEqual(form["sort"].initial, BookmarkSearch.SORT_ADDED_ASC)
        self.assertEqual(form["shared"].initial, BookmarkSearch.FILTER_SHARED_SHARED)
        self.assertEqual(form["unread"].initial, BookmarkSearch.FILTER_UNREAD_YES)

    def test_user_options(self):
        users = [
            self.setup_user("user1"),
            self.setup_user("user2"),
            self.setup_user("user3"),
        ]
        search = BookmarkSearch()
        form = BookmarkSearchForm(search, users=users)

        self.assertCountEqual(
            form["user"].field.choices,
            [
                ("", "Everyone"),
                ("user1", "user1"),
                ("user2", "user2"),
                ("user3", "user3"),
            ],
        )

    def test_hidden_fields(self):
        # no modified params
        search = BookmarkSearch()
        form = BookmarkSearchForm(search)
        self.assertEqual(len(form.hidden_fields()), 0)

        # some modified params
        search = BookmarkSearch(q="search query", sort=BookmarkSearch.SORT_ADDED_ASC)
        form = BookmarkSearchForm(search)
        self.assertCountEqual(form.hidden_fields(), [form["q"], form["sort"]])

        # all modified params
        bundle = self.setup_bundle()
        search = BookmarkSearch(
            q="search query",
            sort=BookmarkSearch.SORT_ADDED_ASC,
            user="user123",
            bundle=bundle,
            shared=BookmarkSearch.FILTER_SHARED_SHARED,
            unread=BookmarkSearch.FILTER_UNREAD_YES,
        )
        form = BookmarkSearchForm(search)
        self.assertCountEqual(
            form.hidden_fields(),
            [
                form["q"],
                form["sort"],
                form["user"],
                form["bundle"],
                form["shared"],
                form["unread"],
            ],
        )

        # some modified params are editable fields
        search = BookmarkSearch(
            q="search query", sort=BookmarkSearch.SORT_ADDED_ASC, user="user123"
        )
        form = BookmarkSearchForm(search, editable_fields=["q", "user"])
        self.assertCountEqual(form.hidden_fields(), [form["sort"]])


================================================
FILE: bookmarks/tests/test_bookmark_search_model.py
================================================
from django.http import QueryDict
from django.test import TestCase

from bookmarks.models import BookmarkSearch
from bookmarks.tests.helpers import BookmarkFactoryMixin


class MockRequest:
    def __init__(self, user):
        self.user = user


class BookmarkSearchModelTest(TestCase, BookmarkFactoryMixin):
    def test_from_request(self):
        # no params
        query_dict = QueryDict()

        search = BookmarkSearch.from_request(None, query_dict)
        self.assertEqual(search.q, "")
        self.assertEqual(search.user, "")
        self.assertEqual(search.bundle, None)
        self.assertEqual(search.sort, BookmarkSearch.SORT_ADDED_DESC)
        self.assertEqual(search.shared, BookmarkSearch.FILTER_SHARED_OFF)
        self.assertEqual(search.unread, BookmarkSearch.FILTER_UNREAD_OFF)

        # some params
        query_dict = QueryDict("q=search query&user=user123")

        bookmark_search = BookmarkSearch.from_request(None, query_dict)
        self.assertEqual(bookmark_search.q, "search query")
        self.assertEqual(bookmark_search.user, "user123")
        self.assertEqual(bookmark_search.sort, BookmarkSearch.SORT_ADDED_DESC)
        self.assertEqual(search.shared, BookmarkSearch.FILTER_SHARED_OFF)
        self.assertEqual(search.unread, BookmarkSearch.FILTER_UNREAD_OFF)

        # all params
        bundle = self.setup_bundle()
        request = MockRequest(self.get_or_create_test_user())
        query_dict = QueryDict(
            f"q=search query&sort=title_asc&user=user123&bundle={bundle.id}&shared=yes&unread=yes"
        )

        search = BookmarkSearch.from_request(request, query_dict)
        self.assertEqual(search.q, "search query")
        self.assertEqual(search.user, "user123")
        self.assertEqual(search.bundle, bundle)
        self.assertEqual(search.sort, BookmarkSearch.SORT_TITLE_ASC)
        self.assertEqual(search.shared, BookmarkSearch.FILTER_SHARED_SHARED)
        self.assertEqual(search.unread, BookmarkSearch.FILTER_UNREAD_YES)

        # respects preferences
        preferences = {
            "sort": BookmarkSearch.SORT_TITLE_ASC,
            "unread": BookmarkSearch.FILTER_UNREAD_YES,
        }
        query_dict = QueryDict("q=search query")

        search = BookmarkSearch.from_request(None, query_dict, preferences)
        self.assertEqual(search.q, "search query")
        self.assertEqual(search.user, "")
        self.assertEqual(search.sort, BookmarkSearch.SORT_TITLE_ASC)
        self.assertEqual(search.shared, BookmarkSearch.FILTER_SHARED_OFF)
        self.assertEqual(search.unread, BookmarkSearch.FILTER_UNREAD_YES)

        # query overrides preferences
        preferences = {
            "sort": BookmarkSearch.SORT_TITLE_ASC,
            "shared": BookmarkSearch.FILTER_SHARED_SHARED,
            "unread": BookmarkSearch.FILTER_UNREAD_YES,
        }
        query_dict = QueryDict("sort=title_desc&shared=no&unread=off")

        search = BookmarkSearch.from_request(None, query_dict, preferences)
        self.assertEqual(search.q, "")
        self.assertEqual(search.user, "")
        self.assertEqual(search.sort, BookmarkSearch.SORT_TITLE_DESC)
        self.assertEqual(search.shared, BookmarkSearch.FILTER_SHARED_UNSHARED)
        self.assertEqual(search.unread, BookmarkSearch.FILTER_UNREAD_OFF)

    def test_from_request_ignores_invalid_bundle_param(self):
        self.setup_bundle()

        # bundle does not exist
        request = MockRequest(self.get_or_create_test_user())
        query_dict = QueryDict("bundle=99999")
        search = BookmarkSearch.from_request(request, query_dict)
        self.assertIsNone(search.bundle)

        # bundle belongs to another user
        other_user = self.setup_user()
        bundle = self.setup_bundle(user=other_user)
        query_dict = QueryDict(f"bundle={bundle.id}")
        search = BookmarkSearch.from_request(request, query_dict)
        self.assertIsNone(search.bundle)

    def test_query_params(self):
        # no params
        search = BookmarkSearch()
        self.assertEqual(search.query_params, {})

        # params are default values
        search = BookmarkSearch(
            q="", sort=BookmarkSearch.SORT_ADDED_DESC, user="", bundle=None, shared=""
        )
        self.assertEqual(search.query_params, {})

        # some modified params
        search = BookmarkSearch(q="search query", sort=BookmarkSearch.SORT_ADDED_ASC)
        self.assertEqual(
            search.query_params,
            {"q": "search query", "sort": BookmarkSearch.SORT_ADDED_ASC},
        )

        # all modified params
        bundle = self.setup_bundle()
        search = BookmarkSearch(
            q="search query",
            sort=BookmarkSearch.SORT_ADDED_ASC,
            user="user123",
            bundle=bundle,
            shared=BookmarkSearch.FILTER_SHARED_SHARED,
            unread=BookmarkSearch.FILTER_UNREAD_YES,
        )
        self.assertEqual(
            search.query_params,
            {
                "q": "search query",
                "sort": BookmarkSearch.SORT_ADDED_ASC,
                "user": "user123",
                "bundle": bundle.id,
                "shared": BookmarkSearch.FILTER_SHARED_SHARED,
                "unread": BookmarkSearch.FILTER_UNREAD_YES,
            },
        )

        # preferences are not query params if they match default
        preferences = {
            "sort": BookmarkSearch.SORT_TITLE_ASC,
            "unread": BookmarkSearch.FILTER_UNREAD_YES,
        }
        search = BookmarkSearch(preferences=preferences)
        self.assertEqual(search.query_params, {})

        # param is not a query param if it matches the preference
        preferences = {
            "sort": BookmarkSearch.SORT_TITLE_ASC,
            "unread": BookmarkSearch.FILTER_UNREAD_YES,
        }
        search = BookmarkSearch(
            sort=BookmarkSearch.SORT_TITLE_ASC,
            unread=BookmarkSearch.FILTER_UNREAD_YES,
            preferences=preferences,
        )
        self.assertEqual(search.query_params, {})

        # overriding preferences is a query param
        preferences = {
            "sort": BookmarkSearch.SORT_TITLE_ASC,
            "shared": BookmarkSearch.FILTER_SHARED_SHARED,
            "unread": BookmarkSearch.FILTER_UNREAD_YES,
        }
        search = BookmarkSearch(
            sort=BookmarkSearch.SORT_TITLE_DESC,
            shared=BookmarkSearch.FILTER_SHARED_UNSHARED,
            unread=BookmarkSearch.FILTER_UNREAD_OFF,
            preferences=preferences,
        )
        self.assertEqual(
            search.query_params,
            {
                "sort": BookmarkSearch.SORT_TITLE_DESC,
                "shared": BookmarkSearch.FILTER_SHARED_UNSHARED,
                "unread": BookmarkSearch.FILTER_UNREAD_OFF,
            },
        )

    def test_modified_params(self):
        # no params
        bookmark_search = BookmarkSearch()
        modified_params = bookmark_search.modified_params
        self.assertEqual(len(modified_params), 0)

        # params are default values
        bookmark_search = BookmarkSearch(
            q="", sort=BookmarkSearch.SORT_ADDED_DESC, user="", shared=""
        )
        modified_params = bookmark_search.modified_params
        self.assertEqual(len(modified_params), 0)

        # some modified params
        bookmark_search = BookmarkSearch(
            q="search query", sort=BookmarkSearch.SORT_ADDED_ASC
        )
        modified_params = bookmark_search.modified_params
        self.assertCountEqual(modified_params, ["q", "sort"])

        # all modified params
        bundle = self.setup_bundle()
        bookmark_search = BookmarkSearch(
            q="search query",
            sort=BookmarkSearch.SORT_ADDED_ASC,
            user="user123",
            bundle=bundle,
            shared=BookmarkSearch.FILTER_SHARED_SHARED,
            unread=BookmarkSearch.FILTER_UNREAD_YES,
        )
        modified_params = bookmark_search.modified_params
        self.assertCountEqual(
            modified_params, ["q", "sort", "user", "bundle", "shared", "unread"]
        )

        # preferences are not modified params
        preferences = {
            "sort": BookmarkSearch.SORT_TITLE_ASC,
            "unread": BookmarkSearch.FILTER_UNREAD_YES,
        }
        bookmark_search = BookmarkSearch(preferences=preferences)
        modified_params = bookmark_search.modified_params
        self.assertEqual(len(modified_params), 0)

        # param is not modified if it matches the preference
        preferences = {
            "sort": BookmarkSearch.SORT_TITLE_ASC,
            "unread": BookmarkSearch.FILTER_UNREAD_YES,
        }
        bookmark_search = BookmarkSearch(
            sort=BookmarkSearch.SORT_TITLE_ASC,
            unread=BookmarkSearch.FILTER_UNREAD_YES,
            preferences=preferences,
        )
        modified_params = bookmark_search.modified_params
        self.assertEqual(len(modified_params), 0)

        # overriding preferences is a modified param
        preferences = {
            "sort": BookmarkSearch.SORT_TITLE_ASC,
            "shared": BookmarkSearch.FILTER_SHARED_SHARED,
            "unread": BookmarkSearch.FILTER_UNREAD_YES,
        }
        bookmark_search = BookmarkSearch(
            sort=BookmarkSearch.SORT_TITLE_DESC,
            shared=BookmarkSearch.FILTER_SHARED_UNSHARED,
            unread=BookmarkSearch.FILTER_UNREAD_OFF,
            preferences=preferences,
        )
        modified_params = bookmark_search.modified_params
        self.assertCountEqual(modified_params, ["sort", "shared", "unread"])

    def test_has_modifications(self):
        # no params
        bookmark_search = BookmarkSearch()
        self.assertFalse(bookmark_search.has_modifications)

        # params are default values
        bookmark_search = BookmarkSearch(
            q="", sort=BookmarkSearch.SORT_ADDED_DESC, user="", shared=""
        )
        self.assertFalse(bookmark_search.has_modifications)

        # modified params
        bookmark_search = BookmarkSearch(
            q="search query", sort=BookmarkSearch.SORT_ADDED_ASC
        )
        self.assertTrue(bookmark_search.has_modifications)

    def test_preferences_dict(self):
        # no params
        bookmark_search = BookmarkSearch()
        self.assertEqual(
            bookmark_search.preferences_dict,
            {
                "sort": BookmarkSearch.SORT_ADDED_DESC,
                "shared": BookmarkSearch.FILTER_SHARED_OFF,
                "unread": BookmarkSearch.FILTER_UNREAD_OFF,
            },
        )

        # with params
        bookmark_search = BookmarkSearch(
            sort=BookmarkSearch.SORT_TITLE_DESC, unread=BookmarkSearch.FILTER_UNREAD_YES
        )
        self.assertEqual(
            bookmark_search.preferences_dict,
            {
                "sort": BookmarkSearch.SORT_TITLE_DESC,
                "shared": BookmarkSearch.FILTER_SHARED_OFF,
                "unread": BookmarkSearch.FILTER_UNREAD_YES,
            },
        )

        # only returns preferences
        bundle = self.setup_bundle()
        bookmark_search = BookmarkSearch(
            q="search query", user="user123", bundle=bundle
        )
        self.assertEqual(
            bookmark_search.preferences_dict,
            {
                "sort": BookmarkSearch.SORT_ADDED_DESC,
                "shared": BookmarkSearch.FILTER_SHARED_OFF,
                "unread": BookmarkSearch.FILTER_UNREAD_OFF,
            },
        )


================================================
FILE: bookmarks/tests/test_bookmark_search_tag.py
================================================
from bs4 import BeautifulSoup
from django.template import RequestContext, Template
from django.test import RequestFactory, TestCase

from bookmarks.models import BookmarkSearch
from bookmarks.tests.helpers import BookmarkFactoryMixin, HtmlTestMixin


class BookmarkSearchTagTest(TestCase, BookmarkFactoryMixin, HtmlTestMixin):
    def render_template(self, url: str, mode: str = ""):
        rf = RequestFactory()
        request = rf.get(url)
        request.user = self.get_or_create_test_user()
        request.user_profile = self.get_or_create_test_user().profile
        search = BookmarkSearch.from_request(request, request.GET)
        context = RequestContext(
            request,
            {
                "request": request,
                "search": search,
                "mode": mode,
            },
        )
        template_to_render = Template(
            "{% load bookmarks %} {% bookmark_search search mode %}"
        )
        return template_to_render.render(context)

    def assertHiddenInput(self, form: BeautifulSoup, name: str, value: str = None):
        element = form.select_one(f'input[name="{name}"][type="hidden"]')
        self.assertIsNotNone(element)

        if value is not None:
            self.assertEqual(element["value"], value)

    def assertNoHiddenInput(self, form: BeautifulSoup, name: str):
        element = form.select_one(f'input[name="{name}"][type="hidden"]')
        self.assertIsNone(element)

    def assertSearchInput(self, form: BeautifulSoup, name: str, value: str = None):
        element = form.select_one(f'ld-search-autocomplete[input-name="{name}"]')
        self.assertIsNotNone(element)

        if value is not None:
            self.assertEqual(element["input-value"], value)

    def assertSelect(self, form: BeautifulSoup, name: str, value: str = None):
        select = form.select_one(f'select[name="{name}"]')
        self.assertIsNotNone(select)

        if value is not None:
            options = select.select("option")
            for option in options:
                if option["value"] == value:
                    self.assertTrue(option.has_attr("selected"))
                else:
                    self.assertFalse(option.has_attr("selected"))

    def assertRadioGroup(self, form: BeautifulSoup, name: str, value: str = None):
        radios = form.select(f'input[name="{name}"][type="radio"]')
        self.assertTrue(len(radios) > 0)

        if value is not None:
            for radio in radios:
                if radio["value"] == value:
                    self.assertTrue(radio.has_attr("checked"))
                else:
                    self.assertFalse(radio.has_attr("checked"))

    def assertNoRadioGroup(self, form: BeautifulSoup, name: str):
        radios = form.select(f'input[name="{name}"][type="radio"]')
        self.assertTrue(len(radios) == 0)

    def assertUnmodifiedLabel(self, html: str, text: str):
        soup = self.make_soup(html)
        label = soup.find("label", string=lambda s: s and s.strip() == text)
        self.assertEqual(label["class"], ["form-label"])

    def assertModifiedLabel(self, html: str, text: str):
        soup = self.make_soup(html)
        label = soup.find("label", string=lambda s: s and s.strip() == text)
        self.assertEqual(label["class"], ["form-label", "text-bold"])

    def test_search_form_inputs(self):
        # Without params
        url = "/test"
        rendered_template = self.render_template(url)
        soup = self.make_soup(rendered_template)
        search_form = soup.select_one("form#search")

        self.assertSearchInput(search_form, "q")
        self.assertNoHiddenInput(search_form, "user")
        self.assertNoHiddenInput(search_form, "sort")
        self.assertNoHiddenInput(search_form, "shared")
        self.assertNoHiddenInput(search_form, "unread")

        # With params
        url = "/test?q=foo&user=john&sort=title_asc&shared=yes&unread=yes"
        rendered_template = self.render_template(url)
        soup = self.make_soup(rendered_template)
        search_form = soup.select_one("form#search")

        self.assertSearchInput(search_form, "q", "foo")
        self.assertHiddenInput(search_form, "user", "john")
        self.assertHiddenInput(search_form, "sort", BookmarkSearch.SORT_TITLE_ASC)
        self.assertHiddenInput(
            search_form, "shared", BookmarkSearch.FILTER_SHARED_SHARED
        )
        self.assertHiddenInput(search_form, "unread", BookmarkSearch.FILTER_UNREAD_YES)

    def test_preferences_form_inputs(self):
        # Without params
        url = "/test"
        rendered_template = self.render_template(url)
        soup = self.make_soup(rendered_template)
        preferences_form = soup.select_one("form#search_preferences")

        self.assertNoHiddenInput(preferences_form, "q")
        self.assertNoHiddenInput(preferences_form, "user")
        self.assertNoHiddenInput(preferences_form, "sort")
        self.assertNoHiddenInput(preferences_form, "shared")
        self.assertNoHiddenInput(preferences_form, "unread")

        self.assertSelect(preferences_form, "sort", BookmarkSearch.SORT_ADDED_DESC)
        self.assertRadioGroup(
            preferences_form, "shared", BookmarkSearch.FILTER_SHARED_OFF
        )
        self.assertRadioGroup(
            preferences_form, "unread", BookmarkSearch.FILTER_UNREAD_OFF
        )

        # With params
        url = "/test?q=foo&user=john&sort=title_asc&shared=yes&unread=yes"
        rendered_template = self.render_template(url)
        soup = self.make_soup(rendered_template)
        preferences_form = soup.select_one("form#search_preferences")

        self.assertHiddenInput(preferences_form, "q", "foo")
        self.assertHiddenInput(preferences_form, "user", "john")
        self.assertNoHiddenInput(preferences_form, "sort")
        self.assertNoHiddenInput(preferences_form, "shared")
        self.assertNoHiddenInput(preferences_form, "unread")

        self.assertSelect(preferences_form, "sort", BookmarkSearch.SORT_TITLE_ASC)
        self.assertRadioGroup(
            preferences_form, "shared", BookmarkSearch.FILTER_SHARED_SHARED
        )
        self.assertRadioGroup(
            preferences_form, "unread", BookmarkSearch.FILTER_UNREAD_YES
        )

    def test_preferences_form_inputs_shared_mode(self):
        # Without params
        url = "/test"
        rendered_template = self.render_template(url, mode="shared")
        soup = self.make_soup(rendered_template)
        preferences_form = soup.select_one("form#search_preferences")

        self.assertNoHiddenInput(preferences_form, "q")
        self.assertNoHiddenInput(preferences_form, "user")
        self.assertNoHiddenInput(preferences_form, "sort")
        self.assertNoHiddenInput(preferences_form, "shared")
        self.assertNoHiddenInput(preferences_form, "unread")

        self.assertSelect(preferences_form, "sort", BookmarkSearch.SORT_ADDED_DESC)
        self.assertNoRadioGroup(preferences_form, "shared")
        self.assertNoRadioGroup(preferences_form, "unread")

        # With params
        url = "/test?q=foo&user=john&sort=title_asc"
        rendered_template = self.render_template(url, mode="shared")
        soup = self.make_soup(rendered_template)
        preferences_form = soup.select_one("form#search_preferences")

        self.assertHiddenInput(preferences_form, "q", "foo")
        self.assertHiddenInput(preferences_form, "user", "john")
        self.assertNoHiddenInput(preferences_form, "sort")
        self.assertNoHiddenInput(preferences_form, "shared")
        self.assertNoHiddenInput(preferences_form, "unread")

        self.assertSelect(preferences_form, "sort", BookmarkSearch.SORT_TITLE_ASC)
        self.assertNoRadioGroup(preferences_form, "shared")
        self.assertNoRadioGroup(preferences_form, "unread")

    def test_modified_indicator(self):
        # Without modifications
        url = "/test"
        rendered_template = self.render_template(url)
        soup = self.make_soup(rendered_template)
        button = soup.select_one("button[aria-label='Search preferences']")

        self.assertNotIn("badge", button["class"])

        # With modifications
        url = "/test?sort=title_asc"
        rendered_template = self.render_template(url)
        soup = self.make_soup(rendered_template)
        button = soup.select_one("button[aria-label='Search preferences']")

        self.assertIn("badge", button["class"])

        # Ignores non-preferences modifications
        url = "/test?q=foo&user=john"
        rendered_template = self.render_template(url)
        soup = self.make_soup(rendered_template)
        button = soup.select_one("button[aria-label='Search preferences']")

        self.assertNotIn("badge", button["class"])

    def test_modified_labels(self):
        # Without modifications
        url = "/test"
        rendered_template = self.render_template(url)

        self.assertUnmodifiedLabel(rendered_template, "Sort by")
        self.assertUnmodifiedLabel(rendered_template, "Shared filter")
        self.assertUnmodifiedLabel(rendered_template, "Unread filter")

        # Modified sort
        url = "/test?sort=title_asc"
        rendered_template = self.render_template(url)
        self.assertModifiedLabel(rendered_template, "Sort by")
        self.assertUnmodifiedLabel(rendered_template, "Shared filter")
        self.assertUnmodifiedLabel(rendered_template, "Unread filter")

        # Modified shared
        url = "/test?shared=yes"
        rendered_template = self.render_template(url)
        self.assertUnmodifiedLabel(rendered_template, "Sort by")
        self.assertModifiedLabel(rendered_template, "Shared filter")
        self.assertUnmodifiedLabel(rendered_template, "Unread filter")

        # Modified unread
        url = "/test?unread=yes"
        rendered_template = self.render_template(url)
        self.assertUnmodifiedLabel(rendered_template, "Sort by")
        self.assertUnmodifiedLabel(rendered_template, "Shared filter")
        self.assertModifiedLabel(rendered_template, "Unread filter")


================================================
FILE: bookmarks/tests/test_bookmark_shared_view.py
================================================
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, BookmarkSearch, UserProfile
from bookmarks.tests.helpers import (
    BookmarkFactoryMixin,
    BookmarkListTestMixin,
    TagCloudTestMixin,
)


class BookmarkSharedViewTestCase(
    TestCase, BookmarkFactoryMixin, BookmarkListTestMixin, TagCloudTestMixin
):
    def authenticate(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">{bookmark.resolved_title}</a>',
            html,
            count=count,
        )

    def assertVisibleUserOptions(self, response, users: list[User]):
        html = response.content.decode()

        user_options = ['<option value="" selected="">Everyone</option>']
        for user in users:
            user_options.append(
                f'<option value="{user.username}">{user.username}</option>'
            )
        user_select_html = f"""
        <select name="user" class="form-select" id="id_user" data-submit-on-change>
            {"".join(user_options)}
        </select>
        """

        self.assertInHTML(user_select_html, html)

    def assertEditLink(self, response, url):
        html = response.content.decode()
        self.assertInHTML(
            f"""
            <a href="{url}">Edit</a>        
        """,
            html,
        )

    def test_should_list_shared_bookmarks_from_all_users_that_have_sharing_enabled(
        self,
    ):
        self.authenticate()
        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("linkding:bookmarks.shared"))

        self.assertVisibleBookmarks(response, visible_bookmarks)
        self.assertInvisibleBookmarks(response, invisible_bookmarks)

    def test_should_list_shared_bookmarks_from_selected_user(self):
        self.authenticate()
        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("linkding: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):
        self.authenticate()
        user = self.setup_user(enable_sharing=True)

        visible_bookmarks = self.setup_numbered_bookmarks(
            3, shared=True, user=user, prefix="foo"
        )
        invisible_bookmarks = self.setup_numbered_bookmarks(3, shared=True, user=user)

        response = self.client.get(reverse("linkding:bookmarks.shared") + "?q=foo")

        self.assertVisibleBookmarks(response, visible_bookmarks)
        self.assertInvisibleBookmarks(response, invisible_bookmarks)

    def test_should_list_bookmarks_matching_bundle(self):
        self.authenticate()
        user = self.setup_user(enable_sharing=True)

        visible_bookmarks = self.setup_numbered_bookmarks(
            3, shared=True, user=user, prefix="foo"
        )
        invisible_bookmarks = self.setup_numbered_bookmarks(3, shared=True, user=user)

        bundle = self.setup_bundle(search="foo")

        response = self.client.get(
            reverse("linkding:bookmarks.shared") + f"?bundle={bundle.id}"
        )

        self.assertVisibleBookmarks(response, visible_bookmarks)
        self.assertInvisibleBookmarks(response, invisible_bookmarks)

    def test_should_list_only_publicly_shared_bookmarks_without_login(self):
        user1 = self.setup_user(enable_sharing=True, enable_public_sharing=True)
        user2 = self.setup_user(enable_sharing=True)

        visible_bookmarks = self.setup_numbered_bookmarks(
            3, shared=True, user=user1, prefix="user1"
        )
        invisible_bookmarks = self.setup_numbered_bookmarks(
            3, shared=True, user=user2, prefix="user2"
        )

        response = self.client.get(reverse("linkding:bookmarks.shared"))

        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,
    ):
        self.authenticate()
        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("linkding:bookmarks.shared"))

        self.assertVisibleTags(response, visible_tags)
        self.assertInvisibleTags(response, invisible_tags)

    def test_should_list_tags_for_shared_bookmarks_from_selected_user(self):
        self.authenticate()
        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("linkding: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):
        self.authenticate()
        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("linkding:bookmarks.shared") + "?q=searchvalue"
        )

        self.assertVisibleTags(response, visible_tags)
        self.assertInvisibleTags(response, invisible_tags)

    def test_should_list_tags_for_bookmarks_matching_bundle(self):
        self.authenticate()
        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]])

        bundle = self.setup_bundle(search="searchvalue")

        response = self.client.get(
            reverse("linkding:bookmarks.shared") + f"?bundle={bundle.id}"
        )

        self.assertVisibleTags(response, visible_tags)
        self.assertInvisibleTags(response, invisible_tags)

    def test_should_list_only_tags_for_publicly_shared_bookmarks_without_login(self):
        user1 = self.setup_user(enable_sharing=True, enable_public_sharing=True)
        user2 = self.setup_user(enable_sharing=True)

        visible_tags = [
            self.setup_tag(user=user1),
            self.setup_tag(user=user1),
        ]
        invisible_tags = [
            self.setup_tag(user=user2),
            self.setup_tag(user=user2),
        ]

        self.setup_bookmark(shared=True, user=user1, tags=[visible_tags[0]])
        self.setup_bookmark(shared=True, user=user1, tags=[visible_tags[1]])

        self.setup_bookmark(shared=True, user=user2, tags=[invisible_tags[0]])
        self.setup_bookmark(shared=True, user=user2, tags=[invisible_tags[1]])

        response = self.client.get(reverse("linkding:bookmarks.shared"))

        self.assertVisibleTags(response, visible_tags)
        self.assertInvisibleTags(response, invisible_tags)

    def test_should_list_users_with_shared_bookmarks_if_sharing_is_enabled(self):
        self.authenticate()
        expected_visible_users = [
            self.setup_user(name="user_a", enable_sharing=True),
            self.setup_user(name="user_b", enable_sharing=True),
        ]
        self.setup_bookmark(shared=True, user=expected_visible_users[0])
        self.setup_bookmark(shared=True, user=expected_visible_users[1])

        self.setup_bookmark(shared=False, user=self.setup_user(enable_sharing=True))
        self.setup_bookmark(shared=True, user=self.setup_user(enable_sharing=False))

        response = self.client.get(reverse("linkding:bookmarks.shared"))
        self.assertVisibleUserOptions(response, expected_visible_users)

    def test_should_list_only_users_with_publicly_shared_bookmarks_without_login(self):
        # users with public sharing enabled
        expected_visible_users = [
            self.setup_user(
                name="user_a", enable_sharing=True, enable_public_sharing=True
            ),
            self.setup_user(
                name="user_b", enable_sharing=True, enable_public_sharing=True
            ),
        ]
        self.setup_bookmark(shared=True, user=expected_visible_users[0])
        self.setup_bookmark(shared=True, user=expected_visible_users[1])

        # users with public sharing disabled
        self.setup_bookmark(shared=True, user=self.setup_user(enable_sharing=True))
        self.setup_bookmark(shared=True, user=self.setup_user(enable_sharing=True))

        response = self.client.get(reverse("linkding:bookmarks.shared"))
        self.assertVisibleUserOptions(response, expected_visible_users)

    def test_should_list_bookmarks_and_tags_for_search_preferences(self):
        self.authenticate()
        other_user = self.setup_user(enable_sharing=True)

        user_profile = self.get_or_create_test_user().profile
        user_profile.search_preferences = {
            "unread": BookmarkSearch.FILTER_UNREAD_YES,
        }
        user_profile.save()

        unread_bookmarks = self.setup_numbered_bookmarks(
            3,
            shared=True,
            unread=True,
            with_tags=True,
            prefix="unread",
            tag_prefix="unread",
            user=other_user,
        )
        read_bookmarks = self.setup_numbered_bookmarks(
            3,
            shared=True,
            unread=False,
            with_tags=True,
            prefix="read",
            tag_prefix="read",
            user=other_user,
        )

        unread_tags = self.get_tags_from_bookmarks(unread_bookmarks)
        read_tags = self.get_tags_from_bookmarks(read_bookmarks)

        response = self.client.get(reverse("linkding:bookmarks.shared"))
        self.assertVisibleBookmarks(response, unread_bookmarks)
        self.assertInvisibleBookmarks(response, read_bookmarks)
        self.assertVisibleTags(response, unread_tags)
        self.assertInvisibleTags(response, read_tags)

    def test_should_open_bookmarks_in_new_page_by_default(self):
        self.authenticate()
        user = self.get_or_create_test_user()
        user.profile.enable_sharing = True
        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("linkding:bookmarks.shared"))

        self.assertVisibleBookmarks(response, visible_bookmarks, "_blank")

    def test_should_open_bookmarks_in_same_page_if_specified_in_user_profile(self):
        self.authenticate()
        user = self.get_or_create_test_user()
        user.profile.enable_sharing = True
        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("linkding:bookmarks.shared"))

        self.assertVisibleBookmarks(response, visible_bookmarks, "_self")

    def test_edit_link_return_url_respects_search_options(self):
        self.authenticate()
        user = self.get_or_create_test_user()
        user.profile.enable_sharing = True
        user.profile.save()

        bookmark = self.setup_bookmark(title="foo", shared=True, user=user)
        edit_url = reverse("linkding:bookmarks.edit", args=[bookmark.id])
        base_url = reverse("linkding:bookmarks.shared")

        # without query params
        return_url = urllib.parse.quote(base_url)
        url = f"{edit_url}?return_url={return_url}"

        response = self.client.get(base_url)
        self.assertEditLink(response, url)

        # with query
        url_params = "?q=foo"
        return_url = urllib.parse.quote(base_url + url_params)
        url = f"{edit_url}?return_url={return_url}"

        response = self.client.get(base_url + url_params)
        self.assertEditLink(response, url)

        # with query and user
        url_params = f"?q=foo&user={user.username}"
        return_url = urllib.parse.quote(base_url + url_params)
        url = f"{edit_url}?return_url={return_url}"

        response = self.client.get(base_url + url_params)
        self.assertEditLink(response, url)

        # with query and sort and page
        url_params = "?q=foo&sort=title_asc&page=2"
        return_url = urllib.parse.quote(base_url + url_params)
        url = f"{edit_url}?return_url={return_url}"

        response = self.client.get(base_url + url_params)
        self.assertEditLink(response, url)

    def test_apply_search_preferences(self):
        # no params
        response = self.client.post(reverse("linkding:bookmarks.shared"))
        self.assertEqual(response.status_code, 302)
        self.assertEqual(response.url, reverse("linkding:bookmarks.shared"))

        # some params
        response = self.client.post(
            reverse("linkding:bookmarks.shared"),
            {
                "q": "foo",
                "sort": BookmarkSearch.SORT_TITLE_ASC,
            },
        )
        self.assertEqual(response.status_code, 302)
        self.assertEqual(
            response.url, reverse("linkding:bookmarks.shared") + "?q=foo&sort=title_asc"
        )

        # params with default value are removed
        response = self.client.post(
            reverse("linkding:bookmarks.shared"),
            {
                "q": "foo",
                "user": "",
                "sort": BookmarkSearch.SORT_ADDED_DESC,
                "shared": BookmarkSearch.FILTER_SHARED_OFF,
                "unread": BookmarkSearch.FILTER_UNREAD_YES,
            },
        )
        self.assertEqual(response.status_code, 302)
        self.assertEqual(
            response.url, reverse("linkding:bookmarks.shared") + "?q=foo&unread=yes"
        )

        # page is removed
        response = self.client.post(
            reverse("linkding:bookmarks.shared"),
            {
                "q": "foo",
                "page": "2",
                "sort": BookmarkSearch.SORT_TITLE_ASC,
            },
        )
        self.assertEqual(response.status_code, 302)
        self.assertEqual(
            response.url, reverse("linkding:bookmarks.shared") + "?q=foo&sort=title_asc"
        )

    def test_save_search_preferences(self):
        self.authenticate()
        user_profile = self.user.profile

        # no params
        self.client.post(
            reverse("linkding:bookmarks.shared"),
            {
                "save": "",
            },
        )
        user_profile.refresh_from_db()
        self.assertEqual(
            user_profile.search_preferences,
            {
                "sort": BookmarkSearch.SORT_ADDED_DESC,
                "shared": BookmarkSearch.FILTER_SHARED_OFF,
                "unread": BookmarkSearch.FILTER_UNREAD_OFF,
            },
        )

        # with param
        self.client.post(
            reverse("linkding:bookmarks.shared"),
            {
                "save": "",
                "sort": BookmarkSearch.SORT_TITLE_ASC,
            },
        )
        user_profile.refresh_from_db()
        self.assertEqual(
            user_profile.search_preferences,
            {
                "sort": BookmarkSearch.SORT_TITLE_ASC,
                "shared": BookmarkSearch.FILTER_SHARED_OFF,
                "unread": BookmarkSearch.FILTER_UNREAD_OFF,
            },
        )

        # add a param
        self.client.post(
            reverse("linkding:bookmarks.shared"),
            {
                "save": "",
                "sort": BookmarkSearch.SORT_TITLE_ASC,
                "unread": BookmarkSearch.FILTER_UNREAD_YES,
            },
        )
        user_profile.refresh_from_db()
        self.assertEqual(
            user_profile.search_preferences,
            {
                "sort": BookmarkSearch.SORT_TITLE_ASC,
                "shared": BookmarkSearch.FILTER_SHARED_OFF,
                "unread": BookmarkSearch.FILTER_UNREAD_YES,
            },
        )

        # remove a param
        self.client.post(
            reverse("linkding:bookmarks.shared"),
            {
                "save": "",
                "unread": BookmarkSearch.FILTER_UNREAD_YES,
            },
        )
        user_profile.refresh_from_db()
        self.assertEqual(
            user_profile.search_preferences,
            {
                "sort": BookmarkSearch.SORT_ADDED_DESC,
                "shared": BookmarkSearch.FILTER_SHARED_OFF,
                "unread": BookmarkSearch.FILTER_UNREAD_YES,
            },
        )

        # ignores non-preferences
        self.client.post(
            reverse("linkding:bookmarks.shared"),
            {
                "save": "",
                "q": "foo",
                "user": "john",
                "page": "3",
                "sort": BookmarkSearch.SORT_TITLE_ASC,
            },
        )
        user_profile.refresh_from_db()
        self.assertEqual(
            user_profile.search_preferences,
            {
                "sort": BookmarkSearch.SORT_TITLE_ASC,
                "shared": BookmarkSearch.FILTER_SHARED_OFF,
                "unread": BookmarkSearch.FILTER_UNREAD_OFF,
            },
        )

    def test_url_encode_bookmark_actions_url(self):
        url = reverse("linkding:bookmarks.shared") + "?q=%23foo"
        response = self.client.get(url)
        html = response.content.decode()
        soup = self.make_soup(html)
        actions_form = soup.select("form.bookmark-actions")[0]

        self.assertEqual(
            actions_form.attrs["action"],
            "/bookmarks/shared/action?q=%23foo",
        )

    def test_encode_search_params(self):
        self.authenticate()
        user = self.get_or_create_test_user()
        user.profile.enable_sharing = True
        user.profile.save()
        bookmark = self.setup_bookmark(description="alert('xss')", shared=True)

        url = reverse("linkding:bookmarks.shared") + "?q=alert(%27xss%27)"
        response = self.client.get(url)
        self.assertNotContains(response, "alert('xss')")
        self.assertContains(response, bookmark.url)

        url = reverse("linkding:bookmarks.shared") + "?sort=alert(%27xss%27)"
        response = self.client.get(url)
        self.assertNotContains(response, "alert('xss')")

        url = reverse("linkding:bookmarks.shared") + "?unread=alert(%27xss%27)"
        response = self.client.get(url)
        self.assertNotContains(response, "alert('xss')")

        url = reverse("linkding:bookmarks.shared") + "?shared=alert(%27xss%27)"
        response = self.client.get(url)
        self.assertNotContains(response, "alert('xss')")

        url = reverse("linkding:bookmarks.shared") + "?user=alert(%27xss%27)"
        response = self.client.get(url)
        self.assertNotContains(response, "alert('xss')")

        url = reverse("linkding:bookmarks.shared") + "?page=alert(%27xss%27)"
        response = self.client.get(url)
        self.assertNotContains(response, "alert('xss')")

    def test_turbo_frame_details_modal_renders_details_modal_update(self):
        bookmark = self.setup_bookmark()
        url = reverse("linkding:bookmarks.shared") + f"?bookmark_id={bookmark.id}"
        response = self.client.get(url, headers={"Turbo-Frame": "details-modal"})

        self.assertEqual(200, response.status_code)

        soup = self.make_soup(response.content.decode())
        self.assertIsNotNone(soup.select_one("turbo-frame#details-modal"))
        self.assertIsNone(soup.select_one("#bookmark-list-container"))
        self.assertIsNone(soup.select_one("#tag-cloud-container"))

    def test_includes_public_shared_rss_feed(self):
        response = self.client.get(reverse("linkding:bookmarks.shared"))
        soup = self.make_soup(response.content.decode())

        feed = soup.select_one('head link[type="application/rss+xml"]')
        self.assertIsNotNone(feed)
        self.assertEqual(feed.attrs["href"], reverse("linkding:feeds.public_shared"))

    def test_tag_menu_visible_for_authenticated_user(self):
        self.authenticate()

        response = self.client.get(reverse("linkding:bookmarks.shared"))
        html = response.content.decode()

        soup = self.make_soup(html)
        tag_menu = soup.find(attrs={"aria-label": "Tags menu"})
        self.assertIsNotNone(tag_menu)

    def test_tag_menu_not_visible_for_unauthenticated_user(self):
        response = self.client.get(reverse("linkding:bookmarks.shared"))
        html = response.content.decode()

        soup = self.make_soup(html)
        tag_menu = soup.find(attrs={"aria-label": "Tags menu"})
        self.assertIsNone(tag_menu)


================================================
FILE: bookmarks/tests/test_bookmark_shared_view_performance.py
================================================
from django.db import connections
from django.db.utils import DEFAULT_DB_ALIAS
from django.test import TransactionTestCase
from django.test.utils import CaptureQueriesContext
from django.urls import reverse

from bookmarks.models import GlobalSettings
from bookmarks.tests.helpers import BookmarkFactoryMixin, HtmlTestMixin


class BookmarkSharedViewPerformanceTestCase(
    TransactionTestCase, BookmarkFactoryMixin, HtmlTestMixin
):
    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 global settings
        GlobalSettings.get()

        # create initial users and bookmarks
        num_initial_bookmarks = 10
        for _ 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("linkding:bookmarks.shared"))
            html = response.content.decode("utf-8")
            soup = self.make_soup(html)
            list_items = soup.select("ul.bookmark-list > li")
            self.assertEqual(len(list_items), num_initial_bookmarks)

        number_of_queries = context.final_queries

        # add more users and bookmarks
        num_additional_bookmarks = 10
        for _ 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("linkding:bookmarks.shared"))
            html = response.content.decode("utf-8")
            soup = self.make_soup(html)
            list_items = soup.select("ul.bookmark-list > li")
            self.assertEqual(
                len(list_items), num_initial_bookmarks + num_additional_bookmarks
            )


================================================
FILE: bookmarks/tests/test_bookmark_validation.py
================================================
import datetime

from django.core.exceptions import ValidationError
from django.test import TestCase, override_settings
from django.test.client import RequestFactory

from bookmarks.forms import BookmarkForm
from bookmarks.models import Bookmark
from bookmarks.tests.helpers import BookmarkFactoryMixin

ENABLED_URL_VALIDATION_TEST_CASES = [
    ("thisisnotavalidurl", False),
    ("http://domain", False),
    ("unknownscheme://domain.com", False),
    ("http://domain.com", True),
    ("http://www.domain.com", True),
    ("https://domain.com", True),
    ("https://www.domain.com", True),
]

DISABLED_URL_VALIDATION_TEST_CASES = [
    ("thisisnotavalidurl", True),
    ("http://domain", True),
    ("unknownscheme://domain.com", True),
    ("http://domain.com", True),
    ("http://www.domain.com", True),
    ("https://domain.com", True),
    ("https://www.domain.com", True),
]


class BookmarkValidationTestCase(TestCase, BookmarkFactoryMixin):
    def setUp(self) -> None:
        self.get_or_create_test_user()

    def test_bookmark_model_should_not_allow_missing_url(self):
        bookmark = Bookmark(
            date_added=datetime.datetime.now(),
            date_modified=datetime.datetime.now(),
            owner=self.user,
        )

        with self.assertRaises(ValidationError):
            bookmark.full_clean()

    def test_bookmark_model_should_not_allow_empty_url(self):
        bookmark = Bookmark(
            url="",
            date_added=datetime.datetime.now(),
            date_modified=datetime.datetime.now(),
            owner=self.user,
        )

        with self.assertRaises(ValidationError):
            bookmark.full_clean()

    @override_settings(LD_DISABLE_URL_VALIDATION=False)
    def test_bookmark_model_should_validate_url_if_not_disabled_in_settings(self):
        self._run_bookmark_model_url_validity_checks(ENABLED_URL_VALIDATION_TEST_CASES)

    @override_settings(LD_DISABLE_URL_VALIDATION=True)
    def test_bookmark_model_should_not_validate_url_if_disabled_in_settings(self):
        self._run_bookmark_model_url_validity_checks(DISABLED_URL_VALIDATION_TEST_CASES)

    def test_bookmark_form_should_validate_required_fields(self):
        rf = RequestFactory()
        request = rf.post("/", data={"url": ""})
        form = BookmarkForm(request)

        self.assertEqual(len(form.errors), 1)
        self.assertIn("required", str(form.errors))

        request = rf.post("/", data={})
        form = BookmarkForm(request)

        self.assertEqual(len(form.errors), 1)
        self.assertIn("required", str(form.errors))

    @override_settings(LD_DISABLE_URL_VALIDATION=False)
    def test_bookmark_form_should_validate_url_if_not_disabled_in_settings(self):
        self._run_bookmark_form_url_validity_checks(ENABLED_URL_VALIDATION_TEST_CASES)

    @override_settings(LD_DISABLE_URL_VALIDATION=True)
    def test_bookmark_form_should_not_validate_url_if_disabled_in_settings(self):
        self._run_bookmark_form_url_validity_checks(DISABLED_URL_VALIDATION_TEST_CASES)

    def _run_bookmark_model_url_validity_checks(self, cases):
        for case in cases:
            url, expectation = case
            bookmark = Bookmark(
                url=url,
                date_added=datetime.datetime.now(),
                date_modified=datetime.datetime.now(),
                owner=self.user,
            )

            try:
                bookmark.full_clean()
                self.assertTrue(expectation, "Did not expect validation error")
            except ValidationError as e:
                self.assertFalse(expectation, "Expected validation error")
                self.assertTrue(
                    "url" in e.message_dict, "Expected URL validation to fail"
                )

    def _run_bookmark_form_url_validity_checks(self, cases):
        for case in cases:
            url, expectation = case
            rf = RequestFactory()
            request = rf.post("/", data={"url": url})
            form = BookmarkForm(request)

            if expectation:
                self.assertEqual(len(form.errors), 0)
            else:
                self.assertEqual(len(form.errors), 1)
                self.assertIn("Enter a valid URL", str(form.errors))


================================================
FILE: bookmarks/tests/test_bookmarks_api.py
================================================
import datetime
import io
import urllib.parse
from collections import OrderedDict
from unittest.mock import ANY, patch

from django.contrib.auth.models import User
from django.test import override_settings
from django.urls import reverse
from django.utils import timezone
from rest_framework import status
from rest_framework.response import Response

import bookmarks.services.bookmarks
from bookmarks.models import Bookmark, BookmarkSearch, UserProfile
from bookmarks.services import website_loader
from bookmarks.services.wayback import generate_fallback_webarchive_url
from bookmarks.services.website_loader import WebsiteMetadata
from bookmarks.tests.helpers import BookmarkFactoryMixin, LinkdingApiTestCase
from bookmarks.utils import app_version


class BookmarksApiTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
    def setUp(self):
        self.mock_assets_upload_snapshot_patcher = patch(
            "bookmarks.services.assets.upload_snapshot",
        )
        self.mock_assets_upload_snapshot = (
            self.mock_assets_upload_snapshot_patcher.start()
        )

    def tearDown(self):
        self.mock_assets_upload_snapshot_patcher.stop()

    def authenticate(self):
        self.api_token = self.setup_api_token()
        self.client.credentials(HTTP_AUTHORIZATION="Token " + self.api_token.key)

    def assertBookmarkListEqual(self, data_list, bookmarks):
        expectations = []
        for bookmark in bookmarks:
            tag_names = [tag.name for tag in bookmark.tags.all()]
            tag_names.sort(key=str.lower)
            expectation = OrderedDict()
            expectation["id"] = bookmark.id
            expectation["url"] = bookmark.url
            expectation["title"] = bookmark.title
            expectation["description"] = bookmark.description
            expectation["notes"] = bookmark.notes
            expectation["web_archive_snapshot_url"] = (
                bookmark.web_archive_snapshot_url
                or generate_fallback_webarchive_url(bookmark.url, bookmark.date_added)
            )
            expectation["favicon_url"] = (
                f"http://testserver/static/{bookmark.favicon_file}"
                if bookmark.favicon_file
                else None
            )
            expectation["preview_image_url"] = (
                f"http://testserver/static/{bookmark.preview_image_file}"
                if bookmark.preview_image_file
                else None
            )
            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"
            )
            expectation["website_title"] = None
            expectation["website_description"] = None
            expectations.append(expectation)

        for data in data_list:
            data["tag_names"].sort(key=str.lower)

        self.assertCountEqual(data_list, expectations)

    def test_list_bookmarks(self):
        self.authenticate()
        bookmarks = self.setup_numbered_bookmarks(5)

        response = self.get(
            reverse("linkding:bookmark-list"), expected_status_code=status.HTTP_200_OK
        )
        self.assertBookmarkListEqual(response.data["results"], bookmarks)

    def test_list_bookmarks_with_more_details(self):
        self.authenticate()
        bookmarks = self.setup_numbered_bookmarks(
            5,
            with_tags=True,
            with_web_archive_snapshot_url=True,
            with_favicon_file=True,
            with_preview_image_file=True,
        )

        response = self.get(
            reverse("linkding:bookmark-list"), expected_status_code=status.HTTP_200_OK
        )
        self.assertBookmarkListEqual(response.data["results"], bookmarks)

    def test_list_bookmarks_returns_none_for_website_title_and_description(self):
        self.authenticate()
        bookmark = self.setup_bookmark()
        bookmark.website_title = "Website title"
        bookmark.website_description = "Website description"
        bookmark.save()

        response = self.get(
            reverse("linkding:bookmark-list"), expected_status_code=status.HTTP_200_OK
        )
        self.assertIsNone(response.data["results"][0]["website_title"])
        self.assertIsNone(response.data["results"][0]["website_description"])

    def test_list_bookmarks_does_not_return_archived_bookmarks(self):
        self.authenticate()
        bookmarks = self.setup_numbered_bookmarks(5)
        self.setup_numbered_bookmarks(5, archived=True)

        response = self.get(
            reverse("linkding:bookmark-list"), expected_status_code=status.HTTP_200_OK
        )
        self.assertBookmarkListEqual(response.data["results"], bookmarks)

    def test_list_bookmarks_should_filter_by_query(self):
        self.authenticate()
        search_value = self.get_random_string()
        bookmarks = self.setup_numbered_bookmarks(5, prefix=search_value)
        self.setup_numbered_bookmarks(5)

        response = self.get(
            reverse("linkding:bookmark-list") + "?q=" + search_value,
            expected_status_code=status.HTTP_200_OK,
        )
        self.assertBookmarkListEqual(response.data["results"], bookmarks)

    def test_list_bookmarks_should_filter_by_bundle(self):
        self.authenticate()
        search_value = self.get_random_string()
        bookmarks = self.setup_numbered_bookmarks(5, prefix=search_value)
        self.setup_numbered_bookmarks(5)
        bundle = self.setup_bundle(search=search_value)

        response = self.get(
            reverse("linkding:bookmark-list") + f"?bundle={bundle.id}",
            expected_status_code=status.HTTP_200_OK,
        )
        self.assertBookmarkListEqual(response.data["results"], bookmarks)

    def test_list_bookmarks_filter_unread(self):
        self.authenticate()
        unread_bookmarks = self.setup_numbered_bookmarks(5, unread=True)
        read_bookmarks = self.setup_numbered_bookmarks(5, unread=False)

        # Filter off
        response = self.get(
            reverse("linkding:bookmark-list"), expected_status_code=status.HTTP_200_OK
        )
        self.assertBookmarkListEqual(
            response.data["results"], unread_bookmarks + read_bookmarks
        )

        # Filter shared
        response = self.get(
            reverse("linkding:bookmark-list") + "?unread=yes",
            expected_status_code=status.HTTP_200_OK,
        )
        self.assertBookmarkListEqual(response.data["results"], unread_bookmarks)

        # Filter unshared
        response = self.get(
            reverse("linkding:bookmark-list") + "?unread=no",
            expected_status_code=status.HTTP_200_OK,
        )
        self.assertBookmarkListEqual(response.data["results"], read_bookmarks)

    def test_list_bookmarks_filter_shared(self):
        self.authenticate()
        unshared_bookmarks = self.setup_numbered_bookmarks(5)
        shared_bookmarks = self.setup_numbered_bookmarks(5, shared=True)

        # Filter off
        response = self.get(
            reverse("linkding:bookmark-list"), expected_status_code=status.HTTP_200_OK
        )
        self.assertBookmarkListEqual(
            response.data["results"], unshared_bookmarks + shared_bookmarks
        )

        # Filter shared
        response = self.get(
            reverse("linkding:bookmark-list") + "?shared=yes",
            expected_status_code=status.HTTP_200_OK,
        )
        self.assertBookmarkListEqual(response.data["results"], shared_bookmarks)

        # Filter unshared
        response = self.get(
            reverse("linkding:bookmark-list") + "?shared=no",
            expected_status_code=status.HTTP_200_OK,
        )
        self.assertBookmarkListEqual(response.data["results"], unshared_bookmarks)

    def test_list_bookmarks_should_respect_sort(self):
        self.authenticate()
        bookmarks = self.setup_numbered_bookmarks(5)
        bookmarks.reverse()

        response = self.get(
            reverse("linkding:bookmark-list") + "?sort=title_desc",
            expected_status_code=status.HTTP_200_OK,
        )
        self.assertBookmarkListEqual(response.data["results"], bookmarks)

    def test_list_archived_bookmarks_does_not_return_unarchived_bookmarks(self):
        self.authenticate()
        self.setup_numbered_bookmarks(5)
        archived_bookmarks = self.setup_numbered_bookmarks(5, archived=True)

        response = self.get(
            reverse("linkding:bookmark-archived"),
            expected_status_code=status.HTTP_200_OK,
        )
        self.assertBookmarkListEqual(response.data["results"], archived_bookmarks)

    def test_list_archived_bookmarks_with_more_details(self):
        self.authenticate()
        archived_bookmarks = self.setup_numbered_bookmarks(
            5,
            archived=True,
            with_tags=True,
            with_web_archive_snapshot_url=True,
            with_favicon_file=True,
            with_preview_image_file=True,
        )

        response = self.get(
            reverse("linkding:bookmark-archived"),
            expected_status_code=status.HTTP_200_OK,
        )
        self.assertBookmarkListEqual(response.data["results"], archived_bookmarks)

    def test_list_archived_bookmarks_should_filter_by_query(self):
        self.authenticate()
        search_value = self.get_random_string()
        archived_bookmarks = self.setup_numbered_bookmarks(
            5, archived=True, prefix=search_value
        )
        self.setup_numbered_bookmarks(5, archived=True)

        response = self.get(
            reverse("linkding:bookmark-archived") + "?q=" + search_value,
            expected_status_code=status.HTTP_200_OK,
        )
        self.assertBookmarkListEqual(response.data["results"], archived_bookmarks)

    def test_list_archived_bookmarks_should_filter_by_bundle(self):
        self.authenticate()
        search_value = self.get_random_string()
        archived_bookmarks = self.setup_numbered_bookmarks(
            5, archived=True, prefix=search_value
        )
        self.setup_numbered_bookmarks(5, archived=True)
        bundle = self.setup_bundle(search=search_value)

        response = self.get(
            reverse("linkding:bookmark-archived") + f"?bundle={bundle.id}",
            expected_status_code=status.HTTP_200_OK,
        )
        self.assertBookmarkListEqual(response.data["results"], archived_bookmarks)

    def test_list_archived_bookmarks_should_respect_sort(self):
        self.authenticate()
        bookmarks = self.setup_numbered_bookmarks(5, archived=True)
        bookmarks.reverse()

        response = self.get(
            reverse("linkding:bookmark-archived") + "?sort=title_desc",
            expected_status_code=status.HTTP_200_OK,
        )
        self.assertBookmarkListEqual(response.data["results"], bookmarks)

    def test_list_shared_bookmarks(self):
        self.authenticate()

        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("linkding:bookmark-shared"),
            expected_status_code=status.HTTP_200_OK,
        )
        self.assertBookmarkListEqual(response.data["results"], shared_bookmarks)

    def test_list_shared_bookmarks_with_more_details(self):
        self.authenticate()

        other_user = self.setup_user(enable_sharing=True)
        shared_bookmarks = self.setup_numbered_bookmarks(
            5,
            shared=True,
            user=other_user,
            with_tags=True,
            with_web_archive_snapshot_url=True,
            with_favicon_file=True,
            with_preview_image_file=True,
        )

        response = self.get(
            reverse("linkding:bookmark-shared"),
            expected_status_code=status.HTTP_200_OK,
        )
        self.assertBookmarkListEqual(response.data["results"], shared_bookmarks)

    def test_list_only_publicly_shared_bookmarks_when_not_logged_in(self):
        user1 = self.setup_user(enable_sharing=True, enable_public_sharing=True)
        user2 = self.setup_user(enable_sharing=True)

        shared_bookmarks = [
            self.setup_bookmark(shared=True, user=user1),
            self.setup_bookmark(shared=True, user=user1),
        ]
        self.setup_bookmark(shared=True, user=user2)
        self.setup_bookmark(shared=True, user=user2)

        response = self.get(
            reverse("linkding: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):
        self.authenticate()

        # 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("linkding: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("linkding: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("linkding: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_list_shared_bookmarks_should_respect_sort(self):
        self.authenticate()
        user = self.setup_user(enable_sharing=True)
        bookmarks = self.setup_numbered_bookmarks(5, shared=True, user=user)
        bookmarks.reverse()

        response = self.get(
            reverse("linkding:bookmark-shared") + "?sort=title_desc",
            expected_status_code=status.HTTP_200_OK,
        )
        self.assertBookmarkListEqual(response.data["results"], bookmarks)

    def test_create_bookmark(self):
        self.authenticate()

        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("linkding:bookmark-list"), data, status.HTTP_201_CREATED)
        bookmark = Bookmark.objects.get(url=data["url"])
        self.assertEqual(bookmark.url, data["url"])
        self.assertEqual(bookmark.title, data["title"])
        self.assertEqual(bookmark.description, data["description"])
        self.assertEqual(bookmark.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_enhances_with_metadata_by_default(self):
        self.authenticate()

        data = {"url": "https://example.com/"}
        with patch.object(website_loader, "load_website_metadata") as mock_load:
            mock_load.return_value = WebsiteMetadata(
                url="https://example.com/",
                title="Website title",
                description="Website description",
                preview_image=None,
            )
            self.post(reverse("linkding:bookmark-list"), data, status.HTTP_201_CREATED)
        bookmark = Bookmark.objects.get(url=data["url"])
        self.assertEqual(bookmark.title, "Website title")
        self.assertEqual(bookmark.description, "Website description")

    def test_create_bookmark_does_not_enhance_with_metadata_if_scraping_is_disabled(
        self,
    ):
        self.authenticate()

        data = {"url": "https://example.com/"}
        with patch.object(website_loader, "load_website_metadata") as mock_load:
            mock_load.return_value = WebsiteMetadata(
                url="https://example.com/",
                title="Website title",
                description="Website description",
                preview_image=None,
            )
            self.post(
                reverse("linkding:bookmark-list") + "?disable_scraping",
                data,
                status.HTTP_201_CREATED,
            )
        bookmark = Bookmark.objects.get(url=data["url"])
        self.assertEqual(bookmark.title, "")
        self.assertEqual(bookmark.description, "")

    def test_create_bookmark_creates_html_snapshot_by_default(self):
        self.authenticate()

        with patch.object(
            bookmarks.services.bookmarks,
            "create_bookmark",
            wraps=bookmarks.services.bookmarks.create_bookmark,
        ) as mock_create_bookmark:
            data = {"url": "https://example.com/"}
            self.post(reverse("linkding:bookmark-list"), data, status.HTTP_201_CREATED)

            mock_create_bookmark.assert_called_with(
                ANY, "", self.get_or_create_test_user(), disable_html_snapshot=False
            )

    def test_create_bookmark_does_not_create_html_snapshot_if_disabled(self):
        self.authenticate()

        with patch.object(
            bookmarks.services.bookmarks,
            "create_bookmark",
            wraps=bookmarks.services.bookmarks.create_bookmark,
        ) as mock_create_bookmark:
            data = {"url": "https://example.com/"}
            self.post(
                reverse("linkding:bookmark-list") + "?disable_html_snapshot",
                data,
                status.HTTP_201_CREATED,
            )

            mock_create_bookmark.assert_called_with(
                ANY, "", self.get_or_create_test_user(), disable_html_snapshot=True
            )

    def test_create_bookmark_with_same_url_updates_existing_bookmark(self):
        self.authenticate()

        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("linkding: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)

    def test_create_bookmark_replaces_whitespace_in_tag_names(self):
        self.authenticate()

        data = {
            "url": "https://example.com/",
            "title": "Test title",
            "description": "Test description",
            "tag_names": ["tag 1", "tag 2"],
        }
        self.post(reverse("linkding:bookmark-list"), data, status.HTTP_201_CREATED)
        bookmark = Bookmark.objects.get(url=data["url"])
        tag_names = [tag.name for tag in bookmark.tags.all()]
        self.assertListEqual(tag_names, ["tag-1", "tag-2"])

    def test_create_bookmark_minimal_payload(self):
        self.authenticate()

        data = {"url": "https://example.com/"}
        self.post(
            reverse("linkding:bookmark-list") + "?disable_scraping",
            data,
            status.HTTP_201_CREATED,
        )

        bookmark = Bookmark.objects.get(url=data["url"])
        self.assertEqual(data["url"], bookmark.url)
        self.assertEqual("", bookmark.title)
        self.assertEqual("", bookmark.description)
        self.assertEqual("", bookmark.notes)
        self.assertFalse(bookmark.is_archived)
        self.assertFalse(bookmark.unread)
        self.assertFalse(bookmark.shared)
        self.assertBookmarkListEqual([], bookmark.tag_names)

    def test_create_archived_bookmark(self):
        self.authenticate()

        data = {
            "url": "https://example.com/",
            "title": "Test title",
            "description": "Test description",
            "is_archived": True,
            "tag_names": ["tag1", "tag2"],
        }
        self.post(reverse("linkding: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_create_bookmark_is_not_archived_by_default(self):
        self.authenticate()

        data = {"url": "https://example.com/"}
        self.post(reverse("linkding:bookmark-list"), data, status.HTTP_201_CREATED)
        bookmark = Bookmark.objects.get(url=data["url"])
        self.assertFalse(bookmark.is_archived)

    def test_create_unread_bookmark(self):
        self.authenticate()

        data = {"url": "https://example.com/", "unread": True}
        self.post(reverse("linkding:bookmark-list"), data, status.HTTP_201_CREATED)
        bookmark = Bookmark.objects.get(url=data["url"])
        self.assertTrue(bookmark.unread)

    def test_create_bookmark_is_not_unread_by_default(self):
        self.authenticate()

        data = {"url": "https://example.com/"}
        self.post(reverse("linkding:bookmark-list"), data, status.HTTP_201_CREATED)
        bookmark = Bookmark.objects.get(url=data["url"])
        self.assertFalse(bookmark.unread)

    def test_create_shared_bookmark(self):
        self.authenticate()

        data = {"url": "https://example.com/", "shared": True}
        self.post(reverse("linkding: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):
        self.authenticate()

        data = {"url": "https://example.com/"}
        self.post(reverse("linkding:bookmark-list"), data, status.HTTP_201_CREATED)
        bookmark = Bookmark.objects.get(url=data["url"])
        self.assertFalse(bookmark.shared)

    def test_create_bookmark_should_add_tags_from_auto_tagging(self):
        tag1 = self.setup_tag()
        tag2 = self.setup_tag()

        self.authenticate()
        profile = self.get_or_create_test_user().profile
        profile.auto_tagging_rules = f"example.com {tag2.name}"
        profile.save()

        data = {"url": "https://example.com/", "tag_names": [tag1.name]}
        self.post(reverse("linkding:bookmark-list"), data, status.HTTP_201_CREATED)
        bookmark = Bookmark.objects.get(url=data["url"])
        self.assertCountEqual(bookmark.tags.all(), [tag1, tag2])

    def test_create_bookmark_should_set_default_dates(self):
        self.authenticate()

        with patch("bookmarks.services.bookmarks.timezone.now") as mock_now:
            fixed_time = timezone.make_aware(datetime.datetime(2024, 1, 15, 12, 0, 0))
            mock_now.return_value = fixed_time

            data = {"url": "https://example.com/"}
            self.post(reverse("linkding:bookmark-list"), data, status.HTTP_201_CREATED)
            bookmark = Bookmark.objects.get(url=data["url"])
            self.assertEqual(bookmark.date_added, fixed_time)
            self.assertEqual(bookmark.date_modified, fixed_time)

    def test_create_bookmark_with_date_added(self):
        self.authenticate()

        date1 = timezone.now() - datetime.timedelta(days=30)
        data = {"url": "https://example.com/", "date_added": date1.isoformat()}
        self.post(reverse("linkding:bookmark-list"), data, status.HTTP_201_CREATED)
        bookmark = Bookmark.objects.get(url=data["url"])
        self.assertEqual(bookmark.date_added.isoformat(), date1.isoformat())

    def test_create_bookmark_with_date_modified(self):
        self.authenticate()

        date1 = timezone.now() - datetime.timedelta(days=15)
        data = {"url": "https://example.com/", "date_modified": date1.isoformat()}
        self.post(reverse("linkding:bookmark-list"), data, status.HTTP_201_CREATED)
        bookmark = Bookmark.objects.get(url=data["url"])
        self.assertEqual(bookmark.date_modified.isoformat(), date1.isoformat())

    def test_get_bookmark(self):
        self.authenticate()
        bookmark = self.setup_bookmark()

        url = reverse("linkding:bookmark-detail", args=[bookmark.id])
        response = self.get(url, expected_status_code=status.HTTP_200_OK)
        self.assertBookmarkListEqual([response.data], [bookmark])

    def test_get_bookmark_with_more_details(self):
        self.authenticate()
        tag1 = self.setup_tag()
        bookmark = self.setup_bookmark(
            web_archive_snapshot_url="https://web.archive.org/web/1/",
            tags=[tag1],
        )

        url = reverse("linkding:bookmark-detail", args=[bookmark.id])
        response = self.get(url, expected_status_code=status.HTTP_200_OK)
        self.assertBookmarkListEqual([response.data], [bookmark])

    def test_get_bookmark_returns_fallback_webarchive_url(self):
        self.authenticate()
        bookmark = self.setup_bookmark(
            web_archive_snapshot_url="",
            url="https://example.com/",
            added=timezone.datetime(2023, 8, 11, 21, 45, 11, tzinfo=datetime.UTC),
        )

        url = reverse("linkding:bookmark-detail", args=[bookmark.id])
        response = self.get(url, expected_status_code=status.HTTP_200_OK)
        self.assertEqual(
            response.data["web_archive_snapshot_url"],
            "https://web.archive.org/web/20230811214511/https://example.com/",
        )

    def test_update_bookmark(self):
        self.authenticate()
        bookmark = self.setup_bookmark()

        data = {"url": "https://example.com/updated"}
        url = reverse("linkding:bookmark-detail", args=[bookmark.id])
        self.put(url, data, expected_status_code=status.HTTP_200_OK)
        updated_bookmark = Bookmark.objects.get(id=bookmark.id)
        self.assertEqual(updated_bookmark.url, data["url"])

    def test_update_bookmark_ignores_readonly_fields(self):
        self.authenticate()
        bookmark = self.setup_bookmark()

        data = {
            "url": "https://example.com/updated",
            "web_archive_snapshot_url": "test",
            "website_title": "test",
            "website_description": "test",
        }
        url = reverse("linkding:bookmark-detail", args=[bookmark.id])
        self.put(url, data, expected_status_code=status.HTTP_200_OK)
        updated_bookmark = Bookmark.objects.get(id=bookmark.id)
        self.assertEqual(data["url"], updated_bookmark.url)
        self.assertNotEqual(
            data["web_archive_snapshot_url"], updated_bookmark.web_archive_snapshot_url
        )
        self.assertNotEqual(data["website_title"], updated_bookmark.website_title)
        self.assertNotEqual(
            data["website_description"], updated_bookmark.website_description
        )

    def test_update_bookmark_fails_without_required_fields(self):
        self.authenticate()
        bookmark = self.setup_bookmark()

        data = {"title": "https://example.com/"}
        url = reverse("linkding:bookmark-detail", args=[bookmark.id])
        self.put(url, data, expected_status_code=status.HTTP_400_BAD_REQUEST)

    def test_update_bookmark_with_minimal_payload_does_not_modify_bookmark(self):
        self.authenticate()
        bookmark = self.setup_bookmark(
            is_archived=True, unread=True, shared=True, tags=[self.setup_tag()]
        )

        data = {"url": "https://example.com/"}
        url = reverse("linkding:bookmark-detail", args=[bookmark.id])
        self.put(url, data, expected_status_code=status.HTTP_200_OK)
        updated_bookmark = Bookmark.objects.get(id=bookmark.id)
        self.assertEqual(updated_bookmark.url, data["url"])
        self.assertEqual(updated_bookmark.title, bookmark.title)
        self.assertEqual(updated_bookmark.description, bookmark.description)
        self.assertEqual(updated_bookmark.notes, bookmark.notes)
        self.assertEqual(updated_bookmark.is_archived, bookmark.is_archived)
        self.assertEqual(updated_bookmark.unread, bookmark.unread)
        self.assertEqual(updated_bookmark.shared, bookmark.shared)
        self.assertListEqual(updated_bookmark.tag_names, bookmark.tag_names)

    def test_update_bookmark_unread_flag(self):
        self.authenticate()
        bookmark = self.setup_bookmark()

        data = {"url": "https://example.com/", "unread": True}
        url = reverse("linkding:bookmark-detail", args=[bookmark.id])
        self.put(url, data, expected_status_code=status.HTTP_200_OK)
        updated_bookmark = Bookmark.objects.get(id=bookmark.id)
        self.assertEqual(updated_bookmark.unread, True)

    def test_update_bookmark_shared_flag(self):
        self.authenticate()
        bookmark = self.setup_bookmark()

        data = {"url": "https://example.com/", "shared": True}
        url = reverse("linkding:bookmark-detail", args=[bookmark.id])
        self.put(url, data, expected_status_code=status.HTTP_200_OK)
        updated_bookmark = Bookmark.objects.get(id=bookmark.id)
        self.assertEqual(updated_bookmark.shared, True)

    def test_update_bookmark_adds_tags_from_auto_tagging(self):
        bookmark = self.setup_bookmark()
        tag1 = self.setup_tag()
        tag2 = self.setup_tag()

        self.authenticate()
        profile = self.get_or_create_test_user().profile
        profile.auto_tagging_rules = f"example.com {tag2.name}"
        profile.save()

        data = {"url": "https://example.com/", "tag_names": [tag1.name]}
        url = reverse("linkding:bookmark-detail", args=[bookmark.id])
        self.put(url, data, expected_status_code=status.HTTP_200_OK)
        updated_bookmark = Bookmark.objects.get(id=bookmark.id)
        self.assertCountEqual(updated_bookmark.tags.all(), [tag1, tag2])

    def test_update_bookmark_should_prevent_duplicate_urls(self):
        self.authenticate()
        edited_bookmark = self.setup_bookmark(url="https://example.com/edited")
        existing_bookmark = self.setup_bookmark(url="https://example.com/existing")
        other_user_bookmark = self.setup_bookmark(
            url="https://example.com/other", user=self.setup_user()
        )

        # if the URL isn't modified it's not a duplicate
        data = {"url": edited_bookmark.url}
        url = reverse("linkding:bookmark-detail", args=[edited_bookmark.id])
        self.put(url, data, expected_status_code=status.HTTP_200_OK)

        # if the URL is already bookmarked by another user, it's not a duplicate
        data = {"url": other_user_bookmark.url}
        url = reverse("linkding:bookmark-detail", args=[edited_bookmark.id])
        self.put(url, data, expected_status_code=status.HTTP_200_OK)

        # if the URL is already bookmarked by the same user, it's a duplicate
        data = {"url": existing_bookmark.url}
        url = reverse("linkding:bookmark-detail", args=[edited_bookmark.id])
        self.put(url, data, expected_status_code=status.HTTP_400_BAD_REQUEST)

    def test_patch_bookmark(self):
        self.authenticate()
        bookmark = self.setup_bookmark()

        data = {"url": "https://example.com"}
        url = reverse("linkding:bookmark-detail", args=[bookmark.id])
        self.patch(url, data, expected_status_code=status.HTTP_200_OK)
        bookmark.refresh_from_db()
        self.assertEqual(bookmark.url, data["url"])

        data = {"title": "Updated title"}
        url = reverse("linkding:bookmark-detail", args=[bookmark.id])
        self.patch(url, data, expected_status_code=status.HTTP_200_OK)
        bookmark.refresh_from_db()
        self.assertEqual(bookmark.title, data["title"])

        data = {"description": "Updated description"}
        url = reverse("linkding:bookmark-detail", args=[bookmark.id])
        self.patch(url, data, expected_status_code=status.HTTP_200_OK)
        bookmark.refresh_from_db()
        self.assertEqual(bookmark.description, data["description"])

        data = {"notes": "Updated notes"}
        url = reverse("linkding:bookmark-detail", args=[bookmark.id])
        self.patch(url, data, expected_status_code=status.HTTP_200_OK)
        bookmark.refresh_from_db()
        self.assertEqual(bookmark.notes, data["notes"])

        data = {"unread": True}
        url = reverse("linkding:bookmark-detail", args=[bookmark.id])
        self.patch(url, data, expected_status_code=status.HTTP_200_OK)
        bookmark.refresh_from_db()
        self.assertTrue(bookmark.unread)

        data = {"unread": False}
        url = reverse("linkding:bookmark-detail", args=[bookmark.id])
        self.patch(url, data, expected_status_code=status.HTTP_200_OK)
        bookmark.refresh_from_db()
        self.assertFalse(bookmark.unread)

        data = {"shared": True}
        url = reverse("linkding:bookmark-detail", args=[bookmark.id])
        self.patch(url, data, expected_status_code=status.HTTP_200_OK)
        bookmark.refresh_from_db()
        self.assertTrue(bookmark.shared)

        data = {"shared": False}
        url = reverse("linkding:bookmark-detail", args=[bookmark.id])
        self.patch(url, data, expected_status_code=status.HTTP_200_OK)
        bookmark.refresh_from_db()
        self.assertFalse(bookmark.shared)

        data = {"tag_names": ["updated-tag-1", "updated-tag-2"]}
        url = reverse("linkding:bookmark-detail", args=[bookmark.id])
        self.patch(url, data, expected_status_code=status.HTTP_200_OK)
        bookmark.refresh_from_db()
        tag_names = [tag.name for tag in bookmark.tags.all()]
        self.assertListEqual(tag_names, ["updated-tag-1", "updated-tag-2"])

    def test_patch_ignores_readonly_fields(self):
        self.authenticate()
        bookmark = self.setup_bookmark()

        data = {
            "web_archive_snapshot_url": "test",
            "website_title": "test",
            "website_description": "test",
        }
        url = reverse("linkding:bookmark-detail", args=[bookmark.id])
        self.patch(url, data, expected_status_code=status.HTTP_200_OK)
        updated_bookmark = Bookmark.objects.get(id=bookmark.id)
        self.assertNotEqual(
            data["web_archive_snapshot_url"], updated_bookmark.web_archive_snapshot_url
        )
        self.assertNotEqual(data["website_title"], updated_bookmark.website_title)
        self.assertNotEqual(
            data["website_description"], updated_bookmark.website_description
        )

    def test_patch_with_empty_payload_does_not_modify_bookmark(self):
        self.authenticate()
        bookmark = self.setup_bookmark(
            is_archived=True, unread=True, shared=True, tags=[self.setup_tag()]
        )

        url = reverse("linkding:bookmark-detail", args=[bookmark.id])
        self.patch(url, {}, expected_status_code=status.HTTP_200_OK)
        updated_bookmark = Bookmark.objects.get(id=bookmark.id)
        self.assertEqual(updated_bookmark.url, bookmark.url)
        self.assertEqual(updated_bookmark.title, bookmark.title)
        self.assertEqual(updated_bookmark.description, bookmark.description)
        self.assertEqual(updated_bookmark.notes, bookmark.notes)
        self.assertEqual(updated_bookmark.is_archived, bookmark.is_archived)
        self.assertEqual(updated_bookmark.unread, bookmark.unread)
        self.assertEqual(updated_bookmark.shared, bookmark.shared)
        self.assertListEqual(updated_bookmark.tag_names, bookmark.tag_names)

    def test_patch_bookmark_adds_tags_from_auto_tagging(self):
        bookmark = self.setup_bookmark()
        tag1 = self.setup_tag()
        tag2 = self.setup_tag()

        self.authenticate()
        profile = self.get_or_create_test_user().profile
        profile.auto_tagging_rules = f"example.com {tag2.name}"
        profile.save()

        data = {"tag_names": [tag1.name]}
        url = reverse("linkding:bookmark-detail", args=[bookmark.id])
        self.patch(url, data, expected_status_code=status.HTTP_200_OK)
        updated_bookmark = Bookmark.objects.get(id=bookmark.id)
        self.assertCountEqual(updated_bookmark.tags.all(), [tag1, tag2])

    def test_delete_bookmark(self):
        self.authenticate()
        bookmark = self.setup_bookmark()

        url = reverse("linkding:bookmark-detail", args=[bookmark.id])
        self.delete(url, expected_status_code=status.HTTP_204_NO_CONTENT)
        self.assertEqual(len(Bookmark.objects.filter(id=bookmark.id)), 0)

    def test_archive(self):
        self.authenticate()
        bookmark = self.setup_bookmark()

        url = reverse("linkding:bookmark-archive", args=[bookmark.id])
        self.post(url, expected_status_code=status.HTTP_204_NO_CONTENT)
        bookmark = Bookmark.objects.get(id=bookmark.id)
        self.assertTrue(bookmark.is_archived)

    def test_unarchive(self):
        self.authenticate()
        bookmark = self.setup_bookmark(is_archived=True)

        url = reverse("linkding:bookmark-unarchive", args=[bookmark.id])
        self.post(url, expected_status_code=status.HTTP_204_NO_CONTENT)
        bookmark = Bookmark.objects.get(id=bookmark.id)
        self.assertFalse(bookmark.is_archived)

    def test_check_returns_no_bookmark_if_url_is_not_bookmarked(self):
        self.authenticate()

        url = reverse("linkding: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):
        self.authenticate()

        with patch.object(
            website_loader, "load_website_metadata"
        ) as mock_load_website_metadata:
            expected_metadata = WebsiteMetadata(
                "https://example.com",
                "Scraped metadata",
                "Scraped description",
                "https://example.com/preview.png",
            )
            mock_load_website_metadata.return_value = expected_metadata

            url = reverse("linkding: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.assertEqual(expected_metadata.url, metadata["url"])
            self.assertEqual(expected_metadata.title, metadata["title"])
            self.assertEqual(expected_metadata.description, metadata["description"])
            self.assertEqual(expected_metadata.preview_image, metadata["preview_image"])

    def test_check_returns_bookmark_if_url_is_bookmarked(self):
        self.authenticate()

        bookmark = self.setup_bookmark(
            url="https://example.com",
            title="Example title",
            description="Example description",
            favicon_file="favicon.png",
            preview_image_file="preview.png",
        )

        url = reverse("linkding: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"])
        self.assertEqual(
            "http://testserver/static/favicon.png", bookmark_data["favicon_url"]
        )
        self.assertEqual(
            "http://testserver/static/preview.png", bookmark_data["preview_image_url"]
        )

    def test_check_returns_scraped_metadata_if_url_is_bookmarked(self):
        self.authenticate()

        self.setup_bookmark(
            url="https://example.com",
        )

        with patch.object(
            website_loader, "load_website_metadata"
        ) as mock_load_website_metadata:
            expected_metadata = WebsiteMetadata(
                "https://example.com",
                "Scraped metadata",
                "Scraped description",
                "https://example.com/preview.png",
            )
            mock_load_website_metadata.return_value = expected_metadata

            url = reverse("linkding: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.assertEqual(expected_metadata.url, metadata["url"])
            self.assertEqual(expected_metadata.title, metadata["title"])
            self.assertEqual(expected_metadata.description, metadata["description"])
            self.assertEqual(expected_metadata.preview_image, metadata["preview_image"])

    def test_check_returns_bookmark_using_normalized_url(self):
        self.authenticate()

        # Create bookmark with one URL variant
        bookmark = self.setup_bookmark(
            url="https://EXAMPLE.COM/path/?z=1&a=2",
            title="Example title",
            description="Example description",
        )

        # Check with different URL variant that should normalize to the same URL
        url = reverse("linkding:bookmark-check")
        check_url = urllib.parse.quote_plus("https://example.com/path?a=2&z=1")
        response = self.get(
            f"{url}?url={check_url}", expected_status_code=status.HTTP_200_OK
        )
        bookmark_data = response.data["bookmark"]

        # Should find the existing bookmark despite URL differences
        self.assertIsNotNone(bookmark_data)
        self.assertEqual(bookmark.id, bookmark_data["id"])
        self.assertEqual(bookmark.title, bookmark_data["title"])

    def test_check_returns_no_auto_tags_if_none_configured(self):
        self.authenticate()

        url = reverse("linkding: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
        )
        auto_tags = response.data["auto_tags"]

        self.assertCountEqual(auto_tags, [])

    def test_check_returns_matching_auto_tags(self):
        self.authenticate()

        profile = self.get_or_create_test_user().profile
        profile.auto_tagging_rules = "example.com tag1 tag2"
        profile.save()

        url = reverse("linkding: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
        )
        auto_tags = response.data["auto_tags"]

        self.assertCountEqual(auto_tags, ["tag1", "tag2"])

    def test_check_ignore_cache(self):
        self.authenticate()

        with patch.object(
            website_loader, "load_website_metadata"
        ) as mock_load_website_metadata:
            expected_metadata = WebsiteMetadata(
                "https://example.com",
                "Scraped metadata",
                "Scraped description",
                "https://example.com/preview.png",
            )
            mock_load_website_metadata.return_value = expected_metadata

            # Does not ignore cache by default
            url = reverse("linkding:bookmark-check")
            check_url = urllib.parse.quote_plus("https://example.com")
            self.get(
                f"{url}?url={check_url}",
                expected_status_code=status.HTTP_200_OK,
            )

            mock_load_website_metadata.assert_called_once_with(
                "https://example.com", ignore_cache=False
            )
            mock_load_website_metadata.reset_mock()

            # Ignores cache based on query param
            self.get(
                f"{url}?url={check_url}&ignore_cache=true",
                expected_status_code=status.HTTP_200_OK,
            )

            mock_load_website_metadata.assert_called_once_with(
                "https://example.com", ignore_cache=True
            )

    def test_can_only_access_own_bookmarks(self):
        self.authenticate()
        self.setup_bookmark()
        self.setup_bookmark(is_archived=True)

        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("linkding:bookmark-list")
        response = self.get(url, expected_status_code=status.HTTP_200_OK)
        self.assertEqual(len(response.data["results"]), 1)

        url = reverse("linkding:bookmark-archived")
        response = self.get(url, expected_status_code=status.HTTP_200_OK)
        self.assertEqual(len(response.data["results"]), 1)

        url = reverse("linkding:bookmark-detail", args=[inaccessible_bookmark.id])
        self.get(url, expected_status_code=status.HTTP_404_NOT_FOUND)

        url = reverse(
            "linkding:bookmark-detail", args=[inaccessible_shared_bookmark.id]
        )
        self.get(url, expected_status_code=status.HTTP_404_NOT_FOUND)

        url = reverse("linkding:bookmark-detail", args=[inaccessible_bookmark.id])
        self.put(
            url,
            {url: "https://example.com/"},
            expected_status_code=status.HTTP_404_NOT_FOUND,
        )
        self.patch(url, expected_status_code=status.HTTP_404_NOT_FOUND)

        url = reverse(
            "linkding:bookmark-detail", args=[inaccessible_shared_bookmark.id]
        )
        self.put(
            url,
            {url: "https://example.com/"},
            expected_status_code=status.HTTP_404_NOT_FOUND,
        )
        self.patch(url, expected_status_code=status.HTTP_404_NOT_FOUND)

        url = reverse("linkding:bookmark-detail", args=[inaccessible_bookmark.id])
        self.delete(url, expected_status_code=status.HTTP_404_NOT_FOUND)

        url = reverse(
            "linkding:bookmark-detail", args=[inaccessible_shared_bookmark.id]
        )
        self.delete(url, expected_status_code=status.HTTP_404_NOT_FOUND)

        url = reverse("linkding:bookmark-archive", args=[inaccessible_bookmark.id])
        self.post(url, expected_status_code=status.HTTP_404_NOT_FOUND)

        url = reverse(
            "linkding:bookmark-archive", args=[inaccessible_shared_bookmark.id]
        )
        self.post(url, expected_status_code=status.HTTP_404_NOT_FOUND)

        url = reverse("linkding:bookmark-unarchive", args=[inaccessible_bookmark.id])
        self.post(url, expected_status_code=status.HTTP_404_NOT_FOUND)

        url = reverse(
            "linkding:bookmark-unarchive", args=[inaccessible_shared_bookmark.id]
        )
        self.post(url, expected_status_code=status.HTTP_404_NOT_FOUND)

        url = reverse("linkding: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"])

    def assertUserProfile(self, response: Response, profile: UserProfile):
        self.assertEqual(response.data["theme"], profile.theme)
        self.assertEqual(
            response.data["bookmark_date_display"], profile.bookmark_date_display
        )
        self.assertEqual(
            response.data["bookmark_link_target"], profile.bookmark_link_target
        )
        self.assertEqual(
            response.data["web_archive_integration"], profile.web_archive_integration
        )
        self.assertEqual(response.data["tag_search"], profile.tag_search)
        self.assertEqual(response.data["enable_sharing"], profile.enable_sharing)
        self.assertEqual(
            response.data["enable_public_sharing"], profile.enable_public_sharing
        )
        self.assertEqual(response.data["enable_favicons"], profile.enable_favicons)
        self.assertEqual(response.data["display_url"], profile.display_url)
        self.assertEqual(response.data["permanent_notes"], profile.permanent_notes)
        self.assertEqual(
            response.data["search_preferences"], profile.search_preferences
        )
        self.assertEqual(response.data["version"], app_version)

    def test_user_profile(self):
        self.authenticate()

        # default profile
        profile = self.user.profile
        url = reverse("linkding:user-profile")
        response = self.get(url, expected_status_code=status.HTTP_200_OK)

        self.assertUserProfile(response, profile)

        # update profile
        profile.theme = "dark"
        profile.bookmark_date_display = "absolute"
        profile.bookmark_link_target = "_self"
        profile.web_archive_integration = "enabled"
        profile.tag_search = "lax"
        profile.enable_sharing = True
        profile.enable_public_sharing = True
        profile.enable_favicons = True
        profile.display_url = True
        profile.permanent_notes = True
        profile.search_preferences = {
            "sort": BookmarkSearch.SORT_TITLE_ASC,
            "shared": BookmarkSearch.FILTER_SHARED_OFF,
            "unread": BookmarkSearch.FILTER_UNREAD_YES,
        }
        profile.save()

        url = reverse("linkding:user-profile")
        response = self.get(url, expected_status_code=status.HTTP_200_OK)

        self.assertUserProfile(response, profile)

    def create_singlefile_upload_body(self):
        url = "https://example.com"
        file_content = b"dummy content"
        file = io.BytesIO(file_content)
        file.name = "snapshot.html"

        return {"url": url, "file": file}

    def test_singlefile_upload(self):
        bookmark = self.setup_bookmark(url="https://example.com")

        self.authenticate()
        response = self.client.post(
            reverse("linkding:bookmark-singlefile"),
            self.create_singlefile_upload_body(),
            format="multipart",
            expected_status_code=status.HTTP_201_CREATED,
        )

        self.assertEqual(response.data["message"], "Snapshot uploaded successfully.")

        self.mock_assets_upload_snapshot.assert_called_once()
        self.mock_assets_upload_snapshot.assert_called_with(bookmark, b"dummy content")

    def test_singlefile_creates_bookmark_if_not_exists(self):
        other_user = self.setup_user()
        self.setup_bookmark(url="https://example.com", user=other_user)

        self.authenticate()
        self.client.post(
            reverse("linkding:bookmark-singlefile"),
            self.create_singlefile_upload_body(),
            format="multipart",
            expected_status_code=status.HTTP_201_CREATED,
        )

        self.assertEqual(Bookmark.objects.count(), 2)

        bookmark = Bookmark.objects.get(
            url="https://example.com", owner=self.get_or_create_test_user()
        )
        self.mock_assets_upload_snapshot.assert_called_once()
        self.mock_assets_upload_snapshot.assert_called_with(bookmark, b"dummy content")

    def test_singlefile_updates_own_bookmark_if_exists(self):
        bookmark = self.setup_bookmark(url="https://example.com")
        other_user = self.setup_user()
        self.setup_bookmark(url="https://example.com", user=other_user)

        self.authenticate()
        self.client.post(
            reverse("linkding:bookmark-singlefile"),
            self.create_singlefile_upload_body(),
            format="multipart",
            expected_status_code=status.HTTP_201_CREATED,
        )

        self.assertEqual(Bookmark.objects.count(), 2)
        self.mock_assets_upload_snapshot.assert_called_once()
        self.mock_assets_upload_snapshot.assert_called_with(bookmark, b"dummy content")

    def test_singlefile_creates_bookmark_without_creating_snapshot(self):
        with patch(
            "bookmarks.services.bookmarks.create_bookmark"
        ) as mock_create_bookmark:
            self.authenticate()
            self.client.post(
                reverse("linkding:bookmark-singlefile"),
                self.create_singlefile_upload_body(),
                format="multipart",
                expected_status_code=status.HTTP_201_CREATED,
            )

            mock_create_bookmark.assert_called_once()
            mock_create_bookmark.assert_called_with(
                ANY, "", self.get_or_create_test_user(), disable_html_snapshot=True
            )

    def test_singlefile_upload_missing_parameters(self):
        self.authenticate()

        # Missing 'url'
        file_content = b"dummy content"
        file = io.BytesIO(file_content)
        file.name = "snapshot.html"
        response = self.client.post(
            reverse("linkding:bookmark-singlefile"),
            {"file": file},
            format="multipart",
            expected_status_code=status.HTTP_400_BAD_REQUEST,
        )
        self.assertEqual(
            response.data["error"], "Both 'url' and 'file' parameters are required."
        )

        # Missing 'file'
        response = self.client.post(
            reverse("linkding:bookmark-singlefile"),
            {"url": "https://example.com"},
            format="multipart",
            expected_status_code=status.HTTP_400_BAD_REQUEST,
        )
        self.assertEqual(
            response.data["error"], "Both 'url' and 'file' parameters are required."
        )

    @override_settings(LD_DISABLE_ASSET_UPLOAD=True)
    def test_singlefile_upload_disabled(self):
        self.authenticate()
        self.client.post(
            reverse("linkding:bookmark-singlefile"),
            self.create_singlefile_upload_body(),
            format="multipart",
            expected_status_code=status.HTTP_403_FORBIDDEN,
        )


================================================
FILE: bookmarks/tests/test_bookmarks_api_performance.py
================================================
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 bookmarks.models import GlobalSettings
from bookmarks.tests.helpers import BookmarkFactoryMixin, LinkdingApiTestCase


class BookmarksApiPerformanceTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
    def setUp(self) -> None:
        self.api_token = self.setup_api_token()
        self.client.credentials(HTTP_AUTHORIZATION="Token " + self.api_token.key)

        # create global settings
        GlobalSettings.get()

    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 _ 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("linkding: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 _ 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("linkding: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 _ 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("linkding:bookmark-shared"),
                expected_status_code=status.HTTP_200_OK,
            )

        number_of_queries = context.final_queries

        self.assertLess(number_of_queries, num_initial_bookmarks)


================================================
FILE: bookmarks/tests/test_bookmarks_api_permissions.py
================================================
import urllib.parse

from django.urls import reverse
from rest_framework import status

from bookmarks.tests.helpers import BookmarkFactoryMixin, LinkdingApiTestCase


class BookmarksApiPermissionsTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
    def authenticate(self) -> None:
        self.api_token = self.setup_api_token()
        self.client.credentials(HTTP_AUTHORIZATION="Token " + self.api_token.key)

    def test_list_bookmarks_requires_authentication(self):
        self.get(
            reverse("linkding:bookmark-list"),
            expected_status_code=status.HTTP_401_UNAUTHORIZED,
        )

        self.authenticate()
        self.get(
            reverse("linkding:bookmark-list"), expected_status_code=status.HTTP_200_OK
        )

    def test_list_archived_bookmarks_requires_authentication(self):
        self.get(
            reverse("linkding:bookmark-archived"),
            expected_status_code=status.HTTP_401_UNAUTHORIZED,
        )

        self.authenticate()
        self.get(
            reverse("linkding:bookmark-archived"),
            expected_status_code=status.HTTP_200_OK,
        )

    def test_list_shared_bookmarks_does_not_require_authentication(self):
        self.get(
            reverse("linkding:bookmark-shared"),
            expected_status_code=status.HTTP_200_OK,
        )

        self.authenticate()
        self.get(
            reverse("linkding:bookmark-shared"),
            expected_status_code=status.HTTP_200_OK,
        )

    def test_create_bookmark_requires_authentication(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("linkding:bookmark-list"), data, status.HTTP_401_UNAUTHORIZED)

        self.authenticate()
        self.post(reverse("linkding:bookmark-list"), data, status.HTTP_201_CREATED)

    def test_get_bookmark_requires_authentication(self):
        bookmark = self.setup_bookmark()
        url = reverse("linkding:bookmark-detail", args=[bookmark.id])

        self.get(url, expected_status_code=status.HTTP_401_UNAUTHORIZED)

        self.authenticate()
        self.get(url, expected_status_code=status.HTTP_200_OK)

    def test_update_bookmark_requires_authentication(self):
        bookmark = self.setup_bookmark()
        data = {"url": "https://example.com/"}
        url = reverse("linkding:bookmark-detail", args=[bookmark.id])

        self.put(url, data, expected_status_code=status.HTTP_401_UNAUTHORIZED)

        self.authenticate()
        self.put(url, data, expected_status_code=status.HTTP_200_OK)

    def test_update_bookmark_only_updates_own_bookmarks(self):
        self.authenticate()

        other_user = self.setup_user()
        bookmark = self.setup_bookmark(user=other_user)
        data = {"url": "https://example.com/"}
        url = reverse("linkding:bookmark-detail", args=[bookmark.id])

        self.put(url, data, expected_status_code=status.HTTP_404_NOT_FOUND)

    def test_patch_bookmark_requires_authentication(self):
        bookmark = self.setup_bookmark()
        data = {"url": "https://example.com"}
        url = reverse("linkding:bookmark-detail", args=[bookmark.id])

        self.patch(url, data, expected_status_code=status.HTTP_401_UNAUTHORIZED)

        self.authenticate()
        self.patch(url, data, expected_status_code=status.HTTP_200_OK)

    def test_patch_bookmark_only_updates_own_bookmarks(self):
        self.authenticate()

        other_user = self.setup_user()
        bookmark = self.setup_bookmark(user=other_user)
        data = {"url": "https://example.com"}
        url = reverse("linkding:bookmark-detail", args=[bookmark.id])

        self.patch(url, data, expected_status_code=status.HTTP_404_NOT_FOUND)

    def test_delete_bookmark_requires_authentication(self):
        bookmark = self.setup_bookmark()
        url = reverse("linkding:bookmark-detail", args=[bookmark.id])

        self.delete(url, expected_status_code=status.HTTP_401_UNAUTHORIZED)

        self.authenticate()
        self.delete(url, expected_status_code=status.HTTP_204_NO_CONTENT)

    def test_archive_requires_authentication(self):
        bookmark = self.setup_bookmark()
        url = reverse("linkding:bookmark-archive", args=[bookmark.id])

        self.post(url, expected_status_code=status.HTTP_401_UNAUTHORIZED)

        self.authenticate()
        self.post(url, expected_status_code=status.HTTP_204_NO_CONTENT)

    def test_unarchive_requires_authentication(self):
        bookmark = self.setup_bookmark(is_archived=True)
        url = reverse("linkding:bookmark-unarchive", args=[bookmark.id])

        self.post(url, expected_status_code=status.HTTP_401_UNAUTHORIZED)

        self.authenticate()
        self.post(url, expected_status_code=status.HTTP_204_NO_CONTENT)

    def test_check_requires_authentication(self):
        url = reverse("linkding:bookmark-check")
        check_url = urllib.parse.quote_plus("https://example.com")

        self.get(
            f"{url}?url={check_url}", expected_status_code=status.HTTP_401_UNAUTHORIZED
        )

        self.authenticate()
        self.get(f"{url}?url={check_url}", expected_status_code=status.HTTP_200_OK)

    def test_user_profile_requires_authentication(self):
        url = reverse("linkding:user-profile")

        self.get(url, expected_status_code=status.HTTP_401_UNAUTHORIZED)

        self.authenticate()
        self.get(url, expected_status_code=status.HTTP_200_OK)

    def test_singlefile_upload_requires_authentication(self):
        url = reverse("linkding:bookmark-singlefile")

        self.post(url, expected_status_code=status.HTTP_401_UNAUTHORIZED)


================================================
FILE: bookmarks/tests/test_bookmarks_list_template.py
================================================
import datetime

from django.contrib.auth.models import AnonymousUser
from django.http import HttpResponse
from django.template import RequestContext, Template
from django.test import RequestFactory, TestCase
from django.urls import reverse
from django.utils import formats, timezone

from bookmarks.middlewares import LinkdingMiddleware
from bookmarks.models import Bookmark, BookmarkSearch, User, UserProfile
from bookmarks.tests.helpers import BookmarkFactoryMixin, HtmlTestMixin
from bookmarks.utils import app_version
from bookmarks.views import contexts


class BookmarkListTemplateTest(TestCase, BookmarkFactoryMixin, HtmlTestMixin):
    def assertBookmarksLink(
        self, html: str, bookmark: Bookmark, link_target: str = "_blank"
    ):
        favicon_img = (
            f'<img class="favicon" src="/static/{bookmark.favicon_file}" alt="">'
            if bookmark.favicon_file
            else ""
        )
        self.assertInHTML(
            f"""
            {favicon_img}
            <a href="{bookmark.url}" 
                target="{link_target}" 
                rel="noopener">
                <span>{bookmark.resolved_title}</span>
            </a>
            """,
            html,
        )

    def assertWebArchiveLink(
        self, html: str, label_content: str, url: str, link_target: str = "_blank"
    ):
        self.assertInHTML(
            f"""
        <a href="{url}"
           title="View snapshot on the Internet Archive Wayback Machine" target="{link_target}" rel="noopener">
            {label_content}
        </a>
        """,
            html,
        )

    def assertViewLink(self, html: str, bookmark: Bookmark, base_url=None):
        self.assertViewLinkCount(html, bookmark, base_url)

    def assertNoViewLink(self, html: str, bookmark: Bookmark, base_url=None):
        self.assertViewLinkCount(html, bookmark, base_url, count=0)

    def assertViewLinkCount(
        self,
        html: str,
        bookmark: Bookmark,
        base_url: str = None,
        count=1,
    ):
        if base_url is None:
            base_url = reverse("linkding:bookmarks.index")
        details_url = base_url + f"?details={bookmark.id}"
        self.assertInHTML(
            f"""
                <a href="{details_url}" class="view-action" data-turbo-action="replace" data-turbo-frame="details-modal">View</a>
            """,
            html,
            count=count,
        )

    def assertEditLinkCount(self, html: str, bookmark: Bookmark, count=1):
        edit_url = reverse("linkding:bookmarks.edit", args=[bookmark.id])
        self.assertInHTML(
            f"""
            <a href="{edit_url}?return_url=/bookmarks">Edit</a>
        """,
            html,
            count=count,
        )

    def assertArchiveLinkCount(self, html: str, bookmark: Bookmark, count=1):
        self.assertInHTML(
            f"""
            <button type="submit" name="archive" value="{bookmark.id}"
               class="btn btn-link btn-sm">Archive</button>
        """,
            html,
            count=count,
        )

    def assertDeleteLinkCount(self, html: str, bookmark: Bookmark, count=1):
        self.assertInHTML(
            f"""
            <button data-confirm type="submit" name="remove" value="{bookmark.id}"
               class="btn btn-link btn-sm">Remove</button>
        """,
            html,
            count=count,
        )

    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):
        self.assertEditLinkCount(html, bookmark, count=count)
        self.assertArchiveLinkCount(html, bookmark, count=count)
        self.assertDeleteLinkCount(html, bookmark, 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):
        # Shared by link
        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.assertFavicon(html, bookmark, True)

    def assertFaviconHidden(self, html: str, bookmark: Bookmark):
        self.assertFavicon(html, bookmark, False)

    def assertFavicon(self, html: str, bookmark: Bookmark, visible=True):
        soup = self.make_soup(html)

        favicon = soup.select_one(".favicon")

        if not visible:
            self.assertIsNone(favicon)
            return

        url = f"/static/{bookmark.favicon_file}"
        self.assertIsNotNone(favicon)
        self.assertEqual(favicon["src"], url)

    def assertPreviewImageVisible(self, html: str, bookmark: Bookmark):
        self.assertPreviewImage(html, bookmark, True)

    def assertPreviewImageHidden(self, html: str, bookmark: Bookmark):
        self.assertPreviewImage(html, bookmark, False)

    def assertPreviewImage(self, html: str, bookmark: Bookmark, visible=True):
        soup = self.make_soup(html)
        preview_image = soup.select_one(".preview-image")

        if not visible:
            self.assertIsNone(preview_image)
            return

        url = f"/static/{bookmark.preview_image_file}"
        self.assertIsNotNone(preview_image)
        self.assertEqual(preview_image["src"], url)

    def assertPreviewImagePlaceholder(self, html: str):
        soup = self.make_soup(html)
        placeholder = soup.select_one(".preview-image.placeholder")
        self.assertIsNotNone(placeholder)

    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">
            {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">
          <div class="markdown">
            {notes_html}
          </div>
        </div>
        """,
            html,
            count=count,
        )

    def assertNotesToggle(self, html: str, count=1):
        self.assertInHTML(
            f"""
        <button type="button" class="btn btn-link btn-sm btn-icon toggle-notes">
          <svg width="16" height="16">
            <use href="/static/icons.svg?v={app_version}#note"></use>
          </svg>
          Notes
        </button>      
          """,
            html,
            count=count,
        )

    def assertUnshareButton(self, html: str, bookmark: Bookmark, count=1):
        self.assertInHTML(
            f"""
        <button type="submit" name="unshare" value="{bookmark.id}"
                class="btn btn-link btn-sm btn-icon"
                data-confirm data-confirm-question="Unshare?">
          <svg width="16" height="16">
            <use href="/static/icons.svg?v={app_version}#share"></use>
          </svg>
          Shared
        </button>    
          """,
            html,
            count=count,
        )

    def assertMarkAsReadButton(self, html: str, bookmark: Bookmark, count=1):
        self.assertInHTML(
            f"""
        <button type="submit" name="mark_as_read" value="{bookmark.id}"
                class="btn btn-link btn-sm btn-icon"
                data-confirm data-confirm-question="Mark as read?">
          <svg width="16" height="16">
            <use href="/static/icons.svg?v={app_version}#unread"></use>
          </svg>
          Unread
        </button>   
          """,
            html,
            count=count,
        )

    def render_template(
        self,
        url="/bookmarks",
        context_type: type[
            contexts.BookmarkListContext
        ] = contexts.ActiveBookmarkListContext,
        user: User | AnonymousUser = None,
        is_preview: bool = False,
    ) -> str:
        rf = RequestFactory()
        request = rf.get(url)
        request.user = user or self.get_or_create_test_user()
        middleware = LinkdingMiddleware(lambda r: HttpResponse())
        middleware(request)

        search = BookmarkSearch.from_request(request, request.GET)
        bookmark_list_context = context_type(request, search)
        if is_preview:
            bookmark_list_context.is_preview = True
        context = RequestContext(request, {"bookmark_list": bookmark_list_context})

        template = Template("{% include 'bookmarks/bookmark_list.html' %}")
        return template.render(context)

    def setup_date_format_test(
        self, date_display_setting: str, web_archive_url: str = ""
    ):
        bookmark = self.setup_bookmark()
        bookmark.date_added = timezone.now() - datetime.timedelta(days=8)
        bookmark.web_archive_snapshot_url = web_archive_url
        bookmark.save()
        user = self.get_or_create_test_user()
        user.profile.bookmark_date_display = date_display_setting
        user.profile.save()
        return bookmark

    def inline_bookmark_description_test(self, bookmark):
        html = self.render_template()
        soup = self.make_soup(html)

        has_description = bool(bookmark.description)
        has_tags = len(bookmark.tags.all()) > 0

        # inline description block exists
        description = soup.select_one(".description.inline.truncate")
        self.assertIsNotNone(description)

        # separate description block does not exist
        separate_description = soup.select_one(".description.separate")
        self.assertIsNone(separate_description)

        # one direct child element per description or tags
        children = description.find_all(recursive=False)
        expected_child_count = (
            0 + (1 if has_description else 0) + (1 if has_tags else 0)
        )
        self.assertEqual(len(children), expected_child_count)

        # has separator between description and tags
        if has_description and has_tags:
            self.assertTrue("|" in description.text)

        # contains description text, without leading/trailing whitespace
        if has_description:
            description_text = description.find("span", string=bookmark.description)
            self.assertIsNotNone(description_text)

        if not has_tags:
            # no tags element
            tags = soup.select_one(".tags")
            self.assertIsNone(tags)
        else:
            # tags element exists
            tags = soup.select_one(".tags")
            self.assertIsNotNone(tags)

            # one link for each tag
            tag_links = tags.find_all("a")
            self.assertEqual(len(tag_links), len(bookmark.tags.all()))

            for tag in bookmark.tags.all():
                tag_link = tags.find("a", string=f"#{tag.name}")
                self.assertIsNotNone(tag_link)
                self.assertEqual(tag_link["href"], f"?q=%23{tag.name}")

    def test_inline_bookmark_description(self):
        profile = self.get_or_create_test_user().profile
        profile.bookmark_description_display = (
            UserProfile.BOOKMARK_DESCRIPTION_DISPLAY_INLINE
        )
        profile.save()

        # no description, no tags
        bookmark = self.setup_bookmark(description="")
        self.inline_bookmark_description_test(bookmark)

        # with description, no tags
        bookmark = self.setup_bookmark(description="Test description")
        self.inline_bookmark_description_test(bookmark)

        # no description, with tags
        Bookmark.objects.all().delete()
        bookmark = self.setup_bookmark(
            description="", tags=[self.setup_tag(), self.setup_tag(), self.setup_tag()]
        )
        self.inline_bookmark_description_test(bookmark)

        # with description, with tags
        Bookmark.objects.all().delete()
        bookmark = self.setup_bookmark(
            description="Test description",
            tags=[self.setup_tag(), self.setup_tag(), self.setup_tag()],
        )
        self.inline_bookmark_description_test(bookmark)

    def separate_bookmark_description_test(self, bookmark):
        html = self.render_template()
        soup = self.make_soup(html)

        has_description = bool(bookmark.description)
        has_tags = len(bookmark.tags.all()) > 0

        # inline description block does not exist
        inline_description = soup.select_one(".description.inline")
        self.assertIsNone(inline_description)

        if not has_description:
            # no description element
            description = soup.select_one(".description")
            self.assertIsNone(description)
        else:
            # contains description text, without leading/trailing whitespace
            description = soup.select_one(".description.separate")
            self.assertIsNotNone(description)
            self.assertEqual(description.text, bookmark.description)

        if not has_tags:
            # no tags element
            tags = soup.select_one(".tags")
            self.assertIsNone(tags)
        else:
            # tags element exists
            tags = soup.select_one(".tags")
            self.assertIsNotNone(tags)

            # one link for each tag
            tag_links = tags.find_all("a")
            self.assertEqual(len(tag_links), len(bookmark.tags.all()))

            for tag in bookmark.tags.all():
                tag_link = tags.find("a", string=f"#{tag.name}")
                self.assertIsNotNone(tag_link)
                self.assertEqual(tag_link["href"], f"?q=%23{tag.name}")

    def test_separate_bookmark_description(self):
        profile = self.get_or_create_test_user().profile
        profile.bookmark_description_display = (
            UserProfile.BOOKMARK_DESCRIPTION_DISPLAY_SEPARATE
        )
        profile.save()

        # no description, no tags
        bookmark = self.setup_bookmark(description="")
        self.separate_bookmark_description_test(bookmark)

        # with description, no tags
        bookmark = self.setup_bookmark(description="Test description")
        self.separate_bookmark_description_test(bookmark)

        # no description, with tags
        Bookmark.objects.all().delete()
        bookmark = self.setup_bookmark(
            description="", tags=[self.setup_tag(), self.setup_tag(), self.setup_tag()]
        )
        self.separate_bookmark_description_test(bookmark)

        # with description, with tags
        Bookmark.objects.all().delete()
        bookmark = self.setup_bookmark(
            description="Test description",
            tags=[self.setup_tag(), self.setup_tag(), self.setup_tag()],
        )
        self.separate_bookmark_description_test(bookmark)

    def test_bookmark_description_max_lines(self):
        self.setup_bookmark()
        html = self.render_template()
        soup = self.make_soup(html)
        bookmark_list = soup.select_one("ul.bookmark-list")
        style = bookmark_list["style"]
        self.assertIn("--ld-bookmark-description-max-lines:1", style)

        profile = self.get_or_create_test_user().profile
        profile.bookmark_description_max_lines = 3
        profile.save()

        html = self.render_template()
        soup = self.make_soup(html)
        bookmark_list = soup.select_one("ul.bookmark-list")
        style = bookmark_list["style"]
        self.assertIn("--ld-bookmark-description-max-lines:3", style)

    def test_bookmark_tag_ordering(self):
        bookmark = self.setup_bookmark()
        tag3 = self.setup_tag(name="tag3")
        tag1 = self.setup_tag(name="tag1")
        tag2 = self.setup_tag(name="tag2")
        bookmark.tags.add(tag3, tag1, tag2)

        html = self.render_template()
        soup = self.make_soup(html)
        tags = soup.select_one(".tags")
        tag_links = tags.find_all("a")
        self.assertEqual(len(tag_links), 3)
        self.assertEqual(tag_links[0].text, "#tag1")
        self.assertEqual(tag_links[1].text, "#tag2")
        self.assertEqual(tag_links[2].text, "#tag3")

    def test_bookmark_tag_query_string(self):
        # appends tag to existing query string
        bookmark = self.setup_bookmark(title="term1 term2")
        tag1 = self.setup_tag(name="tag1")
        bookmark.tags.add(tag1)

        html = self.render_template(url="/bookmarks?q=term1 and term2")
        soup = self.make_soup(html)
        tags = soup.select_one(".tags")
        tag_links = tags.find_all("a")
        self.assertEqual(len(tag_links), 1)
        self.assertEqual(tag_links[0]["href"], "?q=term1+and+term2+%23tag1")

        # wraps or expression in parentheses
        html = self.render_template(url="/bookmarks?q=term1 or term2")
        soup = self.make_soup(html)
        tags = soup.select_one(".tags")
        tag_links = tags.find_all("a")
        self.assertEqual(len(tag_links), 1)
        self.assertEqual(tag_links[0]["href"], "?q=%28term1+or+term2%29+%23tag1")

    def test_should_render_web_archive_link_with_absolute_date_setting(self):
        bookmark = self.setup_date_format_test(
            UserProfile.BOOKMARK_DATE_DISPLAY_ABSOLUTE,
            "https://web.archive.org/web/20210811214511/https://wanikani.com/",
        )
        html = self.render_template()
        formatted_date = formats.date_format(bookmark.date_added, "SHORT_DATE_FORMAT")

        self.assertWebArchiveLink(
            html, formatted_date, bookmark.web_archive_snapshot_url
        )

    def test_should_render_web_archive_link_with_relative_date_setting(self):
        bookmark = self.setup_date_format_test(
            UserProfile.BOOKMARK_DATE_DISPLAY_RELATIVE,
            "https://web.archive.org/web/20210811214511/https://wanikani.com/",
        )
        html = self.render_template()

        self.assertWebArchiveLink(html, "1 week ago", bookmark.web_archive_snapshot_url)

    def test_should_render_generated_web_archive_link_without_saved_snapshot_url(self):
        user = self.get_or_create_test_user()
        user.profile.bookmark_date_display = UserProfile.BOOKMARK_DATE_DISPLAY_ABSOLUTE
        user.profile.save()

        date_added = timezone.datetime(2023, 8, 11, 21, 45, 11, tzinfo=datetime.UTC)
        bookmark = self.setup_bookmark(
            url="https://example.com/article", added=date_added
        )

        html = self.render_template()
        formatted_date = formats.date_format(bookmark.date_added, "SHORT_DATE_FORMAT")

        self.assertWebArchiveLink(
            html,
            formatted_date,
            "https://web.archive.org/web/20230811214511/https://example.com/article",
        )

    def test_bookmark_link_target_should_be_blank_by_default(self):
        bookmark = self.setup_bookmark()
        html = self.render_template()

        self.assertBookmarksLink(html, bookmark, link_target="_blank")

    def test_bookmark_link_target_should_respect_user_profile(self):
        profile = self.get_or_create_test_user().profile
        profile.bookmark_link_target = UserProfile.BOOKMARK_LINK_TARGET_SELF
        profile.save()

        bookmark = self.setup_bookmark()
        html = self.render_template()

        self.assertBookmarksLink(html, bookmark, link_target="_self")

    def test_web_archive_link_target_should_be_blank_by_default(self):
        bookmark = self.setup_bookmark()
        bookmark.date_added = timezone.now() - datetime.timedelta(days=8)
        bookmark.web_archive_snapshot_url = "https://example.com"
        bookmark.save()

        html = self.render_template()

        self.assertWebArchiveLink(
            html, "1 week ago", bookmark.web_archive_snapshot_url, link_target="_blank"
        )

    def test_web_archive_link_target_should_respect_user_profile(self):
        profile = self.get_or_create_test_user().profile
        profile.bookmark_link_target = UserProfile.BOOKMARK_LINK_TARGET_SELF
        profile.save()

        bookmark = self.setup_bookmark()
        bookmark.date_added = timezone.now() - datetime.timedelta(days=8)
        bookmark.web_archive_snapshot_url = "https://example.com"
        bookmark.save()

        html = self.render_template()

        self.assertWebArchiveLink(
            html, "1 week ago", bookmark.web_archive_snapshot_url, link_target="_self"
        )

    def test_should_render_latest_snapshot_link_if_one_exists(self):
        bookmark = self.setup_date_format_test(
            UserProfile.BOOKMARK_DATE_DISPLAY_ABSOLUTE
        )
        bookmark.latest_snapshot = self.setup_asset(bookmark)
        bookmark.save()

        html = self.render_template()
        formatted_date = formats.date_format(bookmark.date_added, "SHORT_DATE_FORMAT")
        snapshot_url = reverse(
            "linkding:assets.view", args=[bookmark.latest_snapshot.id]
        )

        # Check that the snapshot link is rendered with the correct URL and title
        self.assertInHTML(
            f"""
            <a href="{snapshot_url}"
               title="View latest snapshot" target="_blank" rel="noopener">
                {formatted_date}
            </a>
            <span>|</span>
            """,
            html,
        )

    def test_should_reflect_unread_state_as_css_class(self):
        self.setup_bookmark(unread=True)
        html = self.render_template()
        soup = self.make_soup(html)

        list_item = soup.select_one("ul.bookmark-list > li")
        self.assertIsNotNone(list_item)
        self.assertListEqual(["unread"], list_item["class"])

    def test_should_reflect_shared_state_as_css_class(self):
        profile = self.get_or_create_test_user().profile
        profile.enable_sharing = True
        profile.save()

        self.setup_bookmark(shared=True)
        html = self.render_template()
        soup = self.make_soup(html)

        list_item = soup.select_one("ul.bookmark-list > li")
        self.assertIsNotNone(list_item)
        self.assertListEqual(["shared"], list_item["class"])

    def test_should_reflect_both_unread_and_shared_state_as_css_class(self):
        profile = self.get_or_create_test_user().profile
        profile.enable_sharing = True
        profile.save()

        self.setup_bookmark(unread=True, shared=True)
        html = self.render_template()
        soup = self.make_soup(html)

        list_item = soup.select_one("ul.bookmark-list > li")
        self.assertIsNotNone(list_item)
        self.assertListEqual(["unread", "shared"], list_item["class"])

    def test_show_bookmark_actions_for_owned_bookmarks(self):
        bookmark = self.setup_bookmark()
        html = self.render_template()

        self.assertViewLink(html, bookmark)
        self.assertBookmarkActions(html, bookmark)
        self.assertNoShareInfo(html, bookmark)

    def test_hide_view_link(self):
        bookmark = self.setup_bookmark()
        profile = self.get_or_create_test_user().profile
        profile.display_view_bookmark_action = False
        profile.save()

        html = self.render_template()
        self.assertViewLinkCount(html, bookmark, count=0)
        self.assertEditLinkCount(html, bookmark, count=1)
        self.assertArchiveLinkCount(html, bookmark, count=1)
        self.assertDeleteLinkCount(html, bookmark, count=1)

    def test_hide_edit_link(self):
        bookmark = self.setup_bookmark()
        profile = self.get_or_create_test_user().profile
        profile.display_edit_bookmark_action = False
        profile.save()

        html = self.render_template()
        self.assertViewLinkCount(html, bookmark, count=1)
        self.assertEditLinkCount(html, bookmark, count=0)
        self.assertArchiveLinkCount(html, bookmark, count=1)
        self.assertDeleteLinkCount(html, bookmark, count=1)

    def test_hide_archive_link(self):
        bookmark = self.setup_bookmark()
        profile = self.get_or_create_test_user().profile
        profile.display_archive_bookmark_action = False
        profile.save()

        html = self.render_template()
        self.assertViewLinkCount(html, bookmark, count=1)
        self.assertEditLinkCount(html, bookmark, count=1)
        self.assertArchiveLinkCount(html, bookmark, count=0)
        self.assertDeleteLinkCount(html, bookmark, count=1)

    def test_hide_remove_link(self):
        bookmark = self.setup_bookmark()
        profile = self.get_or_create_test_user().profile
        profile.display_remove_bookmark_action = False
        profile.save()

        html = self.render_template()
        self.assertViewLinkCount(html, bookmark, count=1)
        self.assertEditLinkCount(html, bookmark, count=1)
        self.assertArchiveLinkCount(html, bookmark, count=1)
        self.assertDeleteLinkCount(html, bookmark, count=0)

    def test_show_share_info_for_non_owned_bookmarks(self):
        other_user = User.objects.create_user(
            "otheruser", "otheruser@example.com", "password123"
        )
        other_user.profile.enable_sharing = True
        other_user.profile.save()

        bookmark = self.setup_bookmark(user=other_user, shared=True)
        html = self.render_template(context_type=contexts.SharedBookmarkListContext)

        self.assertViewLink(
            html, bookmark, base_url=reverse("linkding:bookmarks.shared")
        )
        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"
        )
        other_user.profile.enable_sharing = True
        other_user.profile.save()

        bookmark = self.setup_bookmark(user=other_user, shared=True, title="foo")
        html = self.render_template(
            url="/bookmarks?q=foo", context_type=contexts.SharedBookmarkListContext
        )

        self.assertInHTML(
            f"""
            <span>Shared by 
                <a href="?q=foo&user={bookmark.owner.username}">{bookmark.owner.username}</a>
            </span>
        """,
            html,
        )

    def test_preview_image_should_be_visible_when_preview_images_enabled(self):
        profile = self.get_or_create_test_user().profile
        profile.enable_preview_images = True
        profile.save()

        bookmark = self.setup_bookmark(preview_image_file="preview.png")
        html = self.render_template()

        self.assertPreviewImageVisible(html, bookmark)

    def test_preview_image_should_be_hidden_when_preview_images_disabled(self):
        profile = self.get_or_create_test_user().profile
        profile.enable_preview_images = False
        profile.save()

        bookmark = self.setup_bookmark(preview_image_file="preview.png")
        html = self.render_template()

        self.assertPreviewImageHidden(html, bookmark)

    def test_preview_image_shows_placeholder_when_there_is_no_preview_image(self):
        profile = self.get_or_create_test_user().profile
        profile.enable_preview_images = True
        profile.save()

        self.setup_bookmark()
        html = self.render_template()

        self.assertPreviewImagePlaceholder(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_template()

        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_template()

        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_template()

        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_template()

        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_template()

        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_template()

        self.assertBookmarkURLHidden(html, bookmark)

    def test_show_mark_as_read_when_unread(self):
        bookmark = self.setup_bookmark(unread=True)
        html = self.render_template()

        self.assertMarkAsReadButton(html, bookmark)

    def test_hide_mark_as_read_when_read(self):
        bookmark = self.setup_bookmark(unread=False)
        html = self.render_template()

        self.assertMarkAsReadButton(html, bookmark, count=0)

    def test_hide_mark_as_read_for_non_owned_bookmarks(self):
        other_user = self.setup_user(enable_sharing=True)

        bookmark = self.setup_bookmark(user=other_user, shared=True, unread=True)
        html = self.render_template(context_type=contexts.SharedBookmarkListContext)

        self.assertBookmarksLink(html, bookmark)
        self.assertMarkAsReadButton(html, bookmark, count=0)

    def test_show_unshare_button_when_shared(self):
        profile = self.get_or_create_test_user().profile
        profile.enable_sharing = True
        profile.save()

        bookmark = self.setup_bookmark(shared=True)
        html = self.render_template()

        self.assertUnshareButton(html, bookmark)

    def test_hide_unshare_button_when_not_shared(self):
        profile = self.get_or_create_test_user().profile
        profile.enable_sharing = True
        profile.save()

        bookmark = self.setup_bookmark(shared=False)
        html = self.render_template()

        self.assertUnshareButton(html, bookmark, count=0)

    def test_hide_unshare_button_when_sharing_is_disabled(self):
        profile = self.get_or_create_test_user().profile
        profile.enable_sharing = False
        profile.save()

        bookmark = self.setup_bookmark(shared=True)
        html = self.render_template()

        self.assertUnshareButton(html, bookmark, count=0)

    def test_hide_unshare_for_non_owned_bookmarks(self):
        other_user = self.setup_user(enable_sharing=True)

        bookmark = self.setup_bookmark(user=other_user, shared=True)
        html = self.render_template(context_type=contexts.SharedBookmarkListContext)

        self.assertBookmarksLink(html, bookmark)
        self.assertUnshareButton(html, bookmark, count=0)

    def test_without_notes(self):
        self.setup_bookmark()
        html = self.render_template()

        self.assertNotes(html, "", 0)
        self.assertNotesToggle(html, 0)

    def test_with_notes(self):
        self.setup_bookmark(notes="Test note")
        html = self.render_template()

        note_html = "<p>Test note</p>"
        self.assertNotes(html, note_html, 1)

    def test_note_renders_markdown(self):
        self.setup_bookmark(notes='**Example:** `print("Hello world!")`')
        html = self.render_template()

        note_html = (
            '<p><strong>Example:</strong> <code>print("Hello world!")</code></p>'
        )
        self.assertNotes(html, note_html, 1)

    def test_note_renders_markdown_with_linkify(self):
        # Should linkify plain URL
        self.setup_bookmark(notes="Example: https://example.com")
        html = self.render_template()

        note_html = '<p>Example: <a href="https://example.com" rel="nofollow">https://example.com</a></p>'
        self.assertNotes(html, note_html, 1)

        # Should not linkify URL in markdown link
        self.setup_bookmark(notes="[https://example.com](https://example.com)")
        html = self.render_template()

        note_html = '<p><a href="https://example.com" rel="nofollow">https://example.com</a></p>'
        self.assertNotes(html, note_html, 1)

    def test_note_linkify_converts_schemeless_urls_to_https(self):
        # Scheme-less URL should become HTTPS
        self.setup_bookmark(notes="Example: example.com")
        html = self.render_template()

        note_html = '<p>Example: <a href="https://example.com" rel="nofollow">example.com</a></p>'
        self.assertNotes(html, note_html, 1)

        # Explicit http:// should stay as http://
        self.setup_bookmark(notes="Example: http://example.com")
        html = self.render_template()

        note_html = '<p>Example: <a href="http://example.com" rel="nofollow">http://example.com</a></p>'
        self.assertNotes(html, note_html, 1)

        # Explicit https:// should stay as https://
        self.setup_bookmark(notes="Example: https://example.com")
        html = self.render_template()

        note_html = '<p>Example: <a href="https://example.com" rel="nofollow">https://example.com</a></p>'
        self.assertNotes(html, note_html, 1)

        # Email addresses should not be affected
        self.setup_bookmark(notes="Contact: hello@example.com")
        html = self.render_template()

        note_html = "<p>Contact: hello@example.com</p>"
        self.assertNotes(html, note_html, 1)

        # ftp:// should not be converted to https
        self.setup_bookmark(notes="FTP: ftp://ftp.example.com")
        html = self.render_template()

        note_html = '<p>FTP: <a href="ftp://ftp.example.com" rel="nofollow">ftp://ftp.example.com</a></p>'
        self.assertNotes(html, note_html, 1)

    def test_note_cleans_html(self):
        self.setup_bookmark(notes='<script>alert("test")</script>')
        self.setup_bookmark(
            notes='<b ld-fetch="https://example.com" ld-on="click">bold text</b>'
        )
        html = self.render_template()

        note_html = '&lt;script&gt;alert("test")&lt;/script&gt;'
        self.assertIn(note_html, html, 1)

        note_html = "<b>bold text</b>"
        self.assertIn(note_html, html, 1)

    def test_notes_are_hidden_initially_by_default(self):
        self.setup_bookmark(notes="Test note")
        html = self.render_template()
        soup = self.make_soup(html)
        bookmark_list = soup.select_one("ul.bookmark-list.show-notes")

        self.assertIsNone(bookmark_list)

    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()

        self.setup_bookmark(notes="Test note")
        html = self.render_template()
        soup = self.make_soup(html)
        bookmark_list = soup.select_one("ul.bookmark-list.show-notes")

        self.assertIsNone(bookmark_list)

    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()

        self.setup_bookmark(notes="Test note")
        html = self.render_template()
        soup = self.make_soup(html)
        bookmark_list = soup.select_one("ul.bookmark-list.show-notes")

        self.assertIsNotNone(bookmark_list)

    def test_toggle_notes_is_visible_by_default(self):
        self.setup_bookmark(notes="Test note")
        html = self.render_template()

        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()

        self.setup_bookmark(notes="Test note")
        html = self.render_template()

        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()

        self.setup_bookmark(notes="Test note")
        html = self.render_template()

        self.assertNotesToggle(html, 0)

    def test_with_anonymous_user(self):
        profile = self.get_or_create_test_user().profile
        profile.enable_sharing = True
        profile.enable_public_sharing = True
        profile.save()

        bookmark = self.setup_bookmark()
        bookmark.date_added = timezone.now() - datetime.timedelta(days=8)
        bookmark.web_archive_snapshot_url = (
            "https://web.archive.org/web/20230531200136/https://example.com"
        )
        bookmark.notes = '**Example:** `print("Hello world!")`'
        bookmark.favicon_file = "https_example_com.png"
        bookmark.shared = True
        bookmark.unread = True
        bookmark.save()

        html = self.render_template(
            context_type=contexts.SharedBookmarkListContext, user=AnonymousUser()
        )
        self.assertBookmarksLink(html, bookmark, link_target="_blank")
        self.assertWebArchiveLink(
            html, "1 week ago", bookmark.web_archive_snapshot_url, link_target="_blank"
        )
        self.assertViewLink(
            html, bookmark, base_url=reverse("linkding:bookmarks.shared")
        )
        self.assertNoBookmarkActions(html, bookmark)
        self.assertShareInfo(html, bookmark)
        self.assertMarkAsReadButton(html, bookmark, count=0)
        self.assertUnshareButton(html, bookmark, count=0)
        note_html = (
            '<p><strong>Example:</strong> <code>print("Hello world!")</code></p>'
        )
        self.assertNotes(html, note_html, 1)
        self.assertFaviconVisible(html, bookmark)

    def test_empty_state(self):
        html = self.render_template()

        self.assertInHTML(
            '<p class="empty-title h5">You have no bookmarks yet</p>', html
        )

    def test_empty_state_with_valid_query_no_results(self):
        self.setup_bookmark(title="Test Bookmark")
        html = self.render_template(url="/bookmarks?q=nonexistent")

        self.assertInHTML(
            '<p class="empty-title h5">You have no bookmarks yet</p>', html
        )

    def test_empty_state_with_invalid_query(self):
        self.setup_bookmark()
        html = self.render_template(url="/bookmarks?q=(test")

        self.assertInHTML('<p class="empty-title h5">Invalid search query</p>', html)
        self.assertIn("Expected RPAREN", html)

    def test_empty_state_with_legacy_search(self):
        profile = self.get_or_create_test_user().profile
        profile.legacy_search = True
        profile.save()

        self.setup_bookmark()
        html = self.render_template(url="/bookmarks?q=(test")

        # With legacy search, search queries are not validated
        self.assertInHTML(
            '<p class="empty-title h5">You have no bookmarks yet</p>', html
        )

    def test_pagination_is_not_sticky_by_default(self):
        self.setup_bookmark()
        html = self.render_template()

        self.assertIn('<div class="bookmark-pagination">', html)

    def test_pagination_is_sticky_when_enabled_in_profile(self):
        self.setup_bookmark()
        profile = self.get_or_create_test_user().profile
        profile.sticky_pagination = True
        profile.save()
        html = self.render_template()

        self.assertIn('<div class="bookmark-pagination sticky">', html)

    def test_items_per_page_is_30_by_default(self):
        self.setup_numbered_bookmarks(50)
        html = self.render_template()

        soup = self.make_soup(html)
        bookmarks = soup.select("ul.bookmark-list > li")
        self.assertEqual(30, len(bookmarks))

    def test_items_per_page_is_configurable(self):
        self.setup_numbered_bookmarks(50)
        profile = self.get_or_create_test_user().profile
        profile.items_per_page = 10
        profile.save()
        html = self.render_template()

        soup = self.make_soup(html)
        bookmarks = soup.select("ul.bookmark-list > li")
        self.assertEqual(10, len(bookmarks))

    def test_no_actions_rendered_when_is_preview(self):
        bookmark = self.setup_bookmark()
        bookmark.date_added = timezone.now() - datetime.timedelta(days=8)
        bookmark.web_archive_snapshot_url = "https://example.com"
        bookmark.save()

        html = self.render_template(is_preview=True)

        # Verify no actions are rendered
        self.assertNoViewLink(html, bookmark)
        self.assertNoBookmarkActions(html, bookmark)
        self.assertMarkAsReadButton(html, bookmark, count=0)
        self.assertUnshareButton(html, bookmark, count=0)
        self.assertNotesToggle(html, count=0)

        # But date should still be rendered
        self.assertWebArchiveLink(html, "1 week ago", bookmark.web_archive_snapshot_url)


================================================
FILE: bookmarks/tests/test_bookmarks_model.py
================================================
from django.test import TestCase

from bookmarks.models import Bookmark


class BookmarkTestCase(TestCase):
    def test_bookmark_resolved_title(self):
        bookmark = Bookmark(
            title="Custom title",
            url="https://example.com",
        )
        self.assertEqual(bookmark.resolved_title, "Custom title")

        bookmark = Bookmark(title="", url="https://example.com")
        self.assertEqual(bookmark.resolved_title, "https://example.com")


================================================
FILE: bookmarks/tests/test_bookmarks_service.py
================================================
import datetime
from unittest.mock import patch

from django.test import TestCase
from django.utils import timezone

from bookmarks.models import Bookmark, Tag
from bookmarks.services import tasks, website_loader
from bookmarks.services.bookmarks import (
    archive_bookmark,
    archive_bookmarks,
    create_bookmark,
    create_html_snapshots,
    delete_bookmarks,
    enhance_with_website_metadata,
    mark_bookmarks_as_read,
    mark_bookmarks_as_unread,
    refresh_bookmarks_metadata,
    share_bookmarks,
    tag_bookmarks,
    unarchive_bookmark,
    unarchive_bookmarks,
    unshare_bookmarks,
    untag_bookmarks,
    update_bookmark,
)
from bookmarks.tests.helpers import BookmarkFactoryMixin


class BookmarkServiceTestCase(TestCase, BookmarkFactoryMixin):
    def setUp(self) -> None:
        self.get_or_create_test_user()

        self.mock_schedule_refresh_metadata_patcher = patch(
            "bookmarks.services.bookmarks.tasks.refresh_metadata"
        )
        self.mock_schedule_refresh_metadata = (
            self.mock_schedule_refresh_metadata_patcher.start()
        )
        self.mock_load_preview_image_patcher = patch(
            "bookmarks.services.bookmarks.tasks.load_preview_image"
        )
        self.mock_load_preview_image = self.mock_load_preview_image_patcher.start()

    def tearDown(self):
        self.mock_schedule_refresh_metadata_patcher.stop()
        self.mock_load_preview_image_patcher.stop()

    def test_create_should_not_update_website_metadata(self):
        with patch.object(
            website_loader, "load_website_metadata"
        ) as mock_load_website_metadata:
            bookmark_data = Bookmark(
                url="https://example.com",
                title="Initial Title",
                description="Initial 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("Initial Title", created_bookmark.title)
            self.assertEqual("Initial description", created_bookmark.description)
            mock_load_website_metadata.assert_not_called()

    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_update_existing_bookmark_with_normalized_url(
        self,
    ):
        original_bookmark = self.setup_bookmark(
            url="https://EXAMPLE.com/path/?a=1&z=2", unread=False, shared=False
        )
        bookmark_data = Bookmark(
            url="HTTPS://example.com/path?z=2&a=1",
            title="Updated Title",
            description="Updated description",
        )
        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)

    def test_create_should_update_existing_bookmark_when_normalized_url_is_empty(
        self,
    ):
        # Test behavior when url_normalized is empty for whatever reason
        # In this case should at least match the URL directly
        original_bookmark = self.setup_bookmark(url="https://example.com")
        Bookmark.objects.update(url_normalized="")
        bookmark_data = Bookmark(
            url="https://example.com",
            title="Updated Title",
            description="Updated description",
        )
        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)

    def test_create_should_update_first_existing_bookmark_for_multiple_duplicates(
        self,
    ):
        first_dupe = self.setup_bookmark(url="https://example.com")
        second_dupe = self.setup_bookmark(url="https://example.com/")

        bookmark_data = Bookmark(
            url="https://example.com",
            title="Updated Title",
            description="Updated description",
        )
        create_bookmark(bookmark_data, "", self.get_or_create_test_user())

        self.assertEqual(Bookmark.objects.count(), 2)

        first_dupe.refresh_from_db()
        self.assertEqual(first_dupe.title, bookmark_data.title)

        second_dupe.refresh_from_db()
        self.assertNotEqual(second_dupe.title, bookmark_data.title)

    def test_create_should_populate_url_normalized_field(self):
        bookmark_data = Bookmark(
            url="https://EXAMPLE.COM/path/?z=1&a=2",
            title="Test Title",
            description="Test description",
        )
        created_bookmark = create_bookmark(
            bookmark_data, "", self.get_or_create_test_user()
        )

        created_bookmark.refresh_from_db()
        self.assertEqual(created_bookmark.url, "https://EXAMPLE.COM/path/?z=1&a=2")
        self.assertEqual(
            created_bookmark.url_normalized, "https://example.com/path?a=2&z=1"
        )

    def test_create_should_create_web_archive_snapshot(self):
        with patch.object(
            tasks, "create_web_archive_snapshot"
        ) as mock_create_web_archive_snapshot:
            bookmark_data = Bookmark(url="https://example.com")
            bookmark = create_bookmark(bookmark_data, "tag1,tag2", self.user)

            mock_create_web_archive_snapshot.assert_called_once_with(
                self.user, bookmark, False
            )

    def test_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_create_should_load_html_snapshot(self):
        with patch.object(tasks, "create_html_snapshot") as mock_create_html_snapshot:
            bookmark_data = Bookmark(url="https://example.com")
            bookmark = create_bookmark(bookmark_data, "tag1,tag2", self.user)

            mock_create_html_snapshot.assert_called_once_with(bookmark)

    def test_create_should_not_load_html_snapshot_when_disabled(self):
        with patch.object(tasks, "create_html_snapshot") as mock_create_html_snapshot:
            bookmark_data = Bookmark(url="https://example.com")
            create_bookmark(
                bookmark_data, "tag1,tag2", self.user, disable_html_snapshot=True
            )

            mock_create_html_snapshot.assert_not_called()

    def test_create_should_not_load_html_snapshot_when_setting_is_disabled(self):
        profile = self.get_or_create_test_user().profile
        profile.enable_automatic_html_snapshots = False
        profile.save()

        with patch.object(tasks, "create_html_snapshot") as mock_create_html_snapshot:
            bookmark_data = Bookmark(url="https://example.com")
            create_bookmark(bookmark_data, "tag1,tag2", self.user)

            mock_create_html_snapshot.assert_not_called()

    def test_create_should_add_tags_from_auto_tagging(self):
        tag1 = self.setup_tag()
        tag2 = self.setup_tag()
        profile = self.get_or_create_test_user().profile
        profile.auto_tagging_rules = f"example.com {tag2.name}"
        profile.save()

        bookmark_data = Bookmark(url="https://example.com")
        bookmark = create_bookmark(bookmark_data, tag1.name, self.user)

        self.assertCountEqual(bookmark.tags.all(), [tag1, tag2])

    def test_create_should_set_default_dates(self):
        with patch("bookmarks.services.bookmarks.timezone.now") as mock_now:
            fixed_time = timezone.make_aware(datetime.datetime(2024, 1, 15, 12, 0, 0))
            mock_now.return_value = fixed_time

            bookmark_data = Bookmark(url="https://example.com")
            bookmark = create_bookmark(bookmark_data, "", self.user)

            bookmark.refresh_from_db()
            self.assertEqual(bookmark.date_added, fixed_time)
            self.assertEqual(bookmark.date_modified, fixed_time)

    def test_create_should_use_provided_date_added(self):
        custom_date = timezone.now() - datetime.timedelta(days=30)
        bookmark_data = Bookmark(url="https://example.com", date_added=custom_date)
        bookmark = create_bookmark(bookmark_data, "", self.user)

        bookmark.refresh_from_db()
        self.assertEqual(bookmark.date_added, custom_date)

    def test_create_should_use_provided_date_modified(self):
        custom_date = timezone.now() - datetime.timedelta(days=15)
        bookmark_data = Bookmark(url="https://example.com", date_modified=custom_date)
        bookmark = create_bookmark(bookmark_data, "", self.user)

        bookmark.refresh_from_db()
        self.assertEqual(bookmark.date_modified, custom_date)

    def test_create_should_use_provided_dates(self):
        custom_date_added = timezone.now() - datetime.timedelta(days=30)
        custom_date_modified = timezone.now() - datetime.timedelta(days=15)
        bookmark_data = Bookmark(
            url="https://example.com",
            date_added=custom_date_added,
            date_modified=custom_date_modified,
        )
        bookmark = create_bookmark(bookmark_data, "", self.user)

        bookmark.refresh_from_db()
        self.assertEqual(bookmark.date_added, custom_date_added)
        self.assertEqual(bookmark.date_modified, custom_date_modified)

    def test_update_should_create_web_archive_snapshot_if_url_did_change(self):
        with patch.object(
            tasks, "create_web_archive_snapshot"
        ) as mock_create_web_archive_snapshot:
            bookmark = self.setup_bookmark()
            bookmark.url = "https://example.com/updated"
            update_bookmark(bookmark, "tag1,tag2", self.user)

            mock_create_web_archive_snapshot.assert_called_once_with(
                self.user, bookmark, True
            )

    def test_update_should_not_create_web_archive_snapshot_if_url_did_not_change(self):
        with patch.object(
            tasks, "create_web_archive_snapshot"
        ) as mock_create_web_archive_snapshot:
            bookmark = self.setup_bookmark()
            bookmark.title = "updated title"
            update_bookmark(bookmark, "tag1,tag2", self.user)

            mock_create_web_archive_snapshot.assert_not_called()

    def test_update_should_not_update_website_metadata(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)
            bookmark.refresh_from_db()

            self.assertEqual("updated title", bookmark.title)
            mock_load_website_metadata.assert_not_called()

    def test_update_should_not_update_website_metadata_if_url_did_change(self):
        with patch.object(
            website_loader, "load_website_metadata"
        ) as mock_load_website_metadata:
            bookmark = self.setup_bookmark(title="initial title")
            bookmark.url = "https://example.com/updated"
            update_bookmark(bookmark, "tag1,tag2", self.user)

            bookmark.refresh_from_db()
            self.assertEqual("initial title", bookmark.title)
            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_update_should_not_create_html_snapshot(self):
        with patch.object(tasks, "create_html_snapshot") as mock_create_html_snapshot:
            bookmark = self.setup_bookmark()
            bookmark.title = "updated title"
            update_bookmark(bookmark, "tag1,tag2", self.user)

            mock_create_html_snapshot.assert_not_called()

    def test_update_should_add_tags_from_auto_tagging(self):
        tag1 = self.setup_tag()
        tag2 = self.setup_tag()
        profile = self.get_or_create_test_user().profile
        profile.auto_tagging_rules = f"example.com {tag2.name}"
        profile.save()
        bookmark = self.setup_bookmark(url="https://example.com")

        update_bookmark(bookmark, tag1.name, self.user)

        self.assertCountEqual(bookmark.tags.all(), [tag1, tag2])

    def test_archive_bookmark(self):
        bookmark = Bookmark(
            url="https://example.com",
            date_added=timezone.now(),
            date_modified=timezone.now(),
            owner=self.user,
        )
        bookmark.save()

        self.assertFalse(bookmark.is_archived)

        archive_bookmark(bookmark)

        updated_bookmark = Bookmark.objects.get(id=bookmark.id)

        self.assertTrue(updated_bookmark.is_archived)

    def test_unarchive_bookmark(self):
        bookmark = Bookmark(
            url="https://example.com",
            date_added=timezone.now(),
            date_modified=timezone.now(),
            owner=self.user,
            is_archived=True,
        )
        bookmark.save()

        unarchive_bookmark(bookmark)

        updated_bookmark = Bookmark.objects.get(id=bookmark.id)

        self.assertFalse(updated_bookmark.is_archived)

    def test_archive_bookmarks(self):
        bookmark1 = self.setup_bookmark()
        bookmark2 = self.setup_bookmark()
        bookmark3 = self.setup_bookmark()

        archive_bookmarks(
            [bookmark1.id, bookmark2.id, bookmark3.id], self.get_or_create_test_user()
        )

        self.assertTrue(Bookmark.objects.get(id=bookmark1.id).is_archived)
        self.assertTrue(Bookmark.objects.get(id=bookmark2.id).is_archived)
        self.assertTrue(Bookmark.objects.get(id=bookmark3.id).is_archived)

    def test_archive_bookmarks_should_only_archive_specified_bookmarks(self):
        bookmark1 = self.setup_bookmark()
        bookmark2 = self.setup_bookmark()
        bookmark3 = self.setup_bookmark()

        archive_bookmarks([bookmark1.id, bookmark3.id], self.get_or_create_test_user())

        self.assertTrue(Bookmark.objects.get(id=bookmark1.id).is_archived)
        self.assertFalse(Bookmark.objects.get(id=bookmark2.id).is_archived)
        self.assertTrue(Bookmark.objects.get(id=bookmark3.id).is_archived)

    def test_archive_bookmarks_should_only_archive_user_owned_bookmarks(self):
        other_user = self.setup_user()
        bookmark1 = self.setup_bookmark()
        bookmark2 = self.setup_bookmark()
        inaccessible_bookmark = self.setup_bookmark(user=other_user)

        archive_bookmarks(
            [bookmark1.id, bookmark2.id, inaccessible_bookmark.id],
            self.get_or_create_test_user(),
        )

        self.assertTrue(Bookmark.objects.get(id=bookmark1.id).is_archived)
        self.assertTrue(Bookmark.objects.get(id=bookmark2.id).is_archived)
        self.assertFalse(Bookmark.objects.get(id=inaccessible_bookmark.id).is_archived)

    def test_archive_bookmarks_should_accept_mix_of_int_and_string_ids(self):
        bookmark1 = self.setup_bookmark()
        bookmark2 = self.setup_bookmark()
        bookmark3 = self.setup_bookmark()

        archive_bookmarks(
            [str(bookmark1.id), bookmark2.id, str(bookmark3.id)],
            self.get_or_create_test_user(),
        )

        self.assertTrue(Bookmark.objects.get(id=bookmark1.id).is_archived)
        self.assertTrue(Bookmark.objects.get(id=bookmark2.id).is_archived)
        self.assertTrue(Bookmark.objects.get(id=bookmark3.id).is_archived)

    def test_unarchive_bookmarks(self):
        bookmark1 = self.setup_bookmark(is_archived=True)
        bookmark2 = self.setup_bookmark(is_archived=True)
        bookmark3 = self.setup_bookmark(is_archived=True)

        unarchive_bookmarks(
            [bookmark1.id, bookmark2.id, bookmark3.id], self.get_or_create_test_user()
        )

        self.assertFalse(Bookmark.objects.get(id=bookmark1.id).is_archived)
        self.assertFalse(Bookmark.objects.get(id=bookmark2.id).is_archived)
        self.assertFalse(Bookmark.objects.get(id=bookmark3.id).is_archived)

    def test_unarchive_bookmarks_should_only_unarchive_specified_bookmarks(self):
        bookmark1 = self.setup_bookmark(is_archived=True)
        bookmark2 = self.setup_bookmark(is_archived=True)
        bookmark3 = self.setup_bookmark(is_archived=True)

        unarchive_bookmarks(
            [bookmark1.id, bookmark3.id], self.get_or_create_test_user()
        )

        self.assertFalse(Bookmark.objects.get(id=bookmark1.id).is_archived)
        self.assertTrue(Bookmark.objects.get(id=bookmark2.id).is_archived)
        self.assertFalse(Bookmark.objects.get(id=bookmark3.id).is_archived)

    def test_unarchive_bookmarks_should_only_unarchive_user_owned_bookmarks(self):
        other_user = self.setup_user()
        bookmark1 = self.setup_bookmark(is_archived=True)
        bookmark2 = self.setup_bookmark(is_archived=True)
        inaccessible_bookmark = self.setup_bookmark(is_archived=True, user=other_user)

        unarchive_bookmarks(
            [bookmark1.id, bookmark2.id, inaccessible_bookmark.id],
            self.get_or_create_test_user(),
        )

        self.assertFalse(Bookmark.objects.get(id=bookmark1.id).is_archived)
        self.assertFalse(Bookmark.objects.get(id=bookmark2.id).is_archived)
        self.assertTrue(Bookmark.objects.get(id=inaccessible_bookmark.id).is_archived)

    def test_unarchive_bookmarks_should_accept_mix_of_int_and_string_ids(self):
        bookmark1 = self.setup_bookmark(is_archived=True)
        bookmark2 = self.setup_bookmark(is_archived=True)
        bookmark3 = self.setup_bookmark(is_archived=True)

        unarchive_bookmarks(
            [str(bookmark1.id), bookmark2.id, str(bookmark3.id)],
            self.get_or_create_test_user(),
        )

        self.assertFalse(Bookmark.objects.get(id=bookmark1.id).is_archived)
        self.assertFalse(Bookmark.objects.get(id=bookmark2.id).is_archived)
        self.assertFalse(Bookmark.objects.get(id=bookmark3.id).is_archived)

    def test_delete_bookmarks(self):
        bookmark1 = self.setup_bookmark()
        bookmark2 = self.setup_bookmark()
        bookmark3 = self.setup_bookmark()

        delete_bookmarks(
            [bookmark1.id, bookmark2.id, bookmark3.id], self.get_or_create_test_user()
        )

        self.assertIsNone(Bookmark.objects.filter(id=bookmark1.id).first())
        self.assertIsNone(Bookmark.objects.filter(id=bookmark2.id).first())
        self.assertIsNone(Bookmark.objects.filter(id=bookmark3.id).first())

    def test_delete_bookmarks_should_only_delete_specified_bookmarks(self):
        bookmark1 = self.setup_bookmark()
        bookmark2 = self.setup_bookmark()
        bookmark3 = self.setup_bookmark()

        delete_bookmarks([bookmark1.id, bookmark3.id], self.get_or_create_test_user())

        self.assertIsNone(Bookmark.objects.filter(id=bookmark1.id).first())
        self.assertIsNotNone(Bookmark.objects.filter(id=bookmark2.id).first())
        self.assertIsNone(Bookmark.objects.filter(id=bookmark3.id).first())

    def test_delete_bookmarks_should_only_delete_user_owned_bookmarks(self):
        other_user = self.setup_user()
        bookmark1 = self.setup_bookmark()
        bookmark2 = self.setup_bookmark()
        inaccessible_bookmark = self.setup_bookmark(user=other_user)

        delete_bookmarks(
            [bookmark1.id, bookmark2.id, inaccessible_bookmark.id],
            self.get_or_create_test_user(),
        )

        self.assertIsNone(Bookmark.objects.filter(id=bookmark1.id).first())
        self.assertIsNone(Bookmark.objects.filter(id=bookmark2.id).first())
        self.assertIsNotNone(
            Bookmark.objects.filter(id=inaccessible_bookmark.id).first()
        )

    def test_delete_bookmarks_should_accept_mix_of_int_and_string_ids(self):
        bookmark1 = self.setup_bookmark()
        bookmark2 = self.setup_bookmark()
        bookmark3 = self.setup_bookmark()

        delete_bookmarks(
            [bookmark1.id, bookmark2.id, bookmark3.id], self.get_or_create_test_user()
        )

        self.assertIsNone(Bookmark.objects.filter(id=bookmark1.id).first())
        self.assertIsNone(Bookmark.objects.filter(id=bookmark2.id).first())
        self.assertIsNone(Bookmark.objects.filter(id=bookmark3.id).first())

    def test_tag_bookmarks(self):
        bookmark1 = self.setup_bookmark()
        bookmark2 = self.setup_bookmark()
        bookmark3 = self.setup_bookmark()
        tag1 = self.setup_tag()
        tag2 = self.setup_tag()

        tag_bookmarks(
            [bookmark1.id, bookmark2.id, bookmark3.id],
            f"{tag1.name},{tag2.name}",
            self.get_or_create_test_user(),
        )

        bookmark1.refresh_from_db()
        bookmark2.refresh_from_db()
        bookmark3.refresh_from_db()

        self.assertCountEqual(bookmark1.tags.all(), [tag1, tag2])
        self.assertCountEqual(bookmark2.tags.all(), [tag1, tag2])
        self.assertCountEqual(bookmark3.tags.all(), [tag1, tag2])

    def test_tag_bookmarks_should_create_tags(self):
        bookmark1 = self.setup_bookmark()
        bookmark2 = self.setup_bookmark()
        bookmark3 = self.setup_bookmark()

        tag_bookmarks(
            [bookmark1.id, bookmark2.id, bookmark3.id],
            "tag1,tag2",
            self.get_or_create_test_user(),
        )

        bookmark1.refresh_from_db()
        bookmark2.refresh_from_db()
        bookmark3.refresh_from_db()

        self.assertEqual(2, Tag.objects.count())

        tag1 = Tag.objects.filter(name="tag1").first()
        tag2 = Tag.objects.filter(name="tag2").first()

        self.assertIsNotNone(tag1)
        self.assertIsNotNone(tag2)

        self.assertCountEqual(bookmark1.tags.all(), [tag1, tag2])
        self.assertCountEqual(bookmark2.tags.all(), [tag1, tag2])
        self.assertCountEqual(bookmark3.tags.all(), [tag1, tag2])

    def test_tag_bookmarks_should_handle_existing_relationships(self):
        tag1 = self.setup_tag()
        tag2 = self.setup_tag()
        bookmark1 = self.setup_bookmark(tags=[tag1])
        bookmark2 = self.setup_bookmark(tags=[tag1])
        bookmark3 = self.setup_bookmark(tags=[tag1])

        BookmarkToTagRelationShip = Bookmark.tags.through
        self.assertEqual(3, BookmarkToTagRelationShip.objects.count())

        tag_bookmarks(
            [bookmark1.id, bookmark2.id, bookmark3.id],
            f"{tag1.name},{tag2.name}",
            self.get_or_create_test_user(),
        )

        bookmark1.refresh_from_db()
        bookmark2.refresh_from_db()
        bookmark3.refresh_from_db()

        self.assertCountEqual(bookmark1.tags.all(), [tag1, tag2])
        self.assertCountEqual(bookmark2.tags.all(), [tag1, tag2])
        self.assertCountEqual(bookmark3.tags.all(), [tag1, tag2])
        self.assertEqual(6, BookmarkToTagRelationShip.objects.count())

    def test_tag_bookmarks_should_only_tag_specified_bookmarks(self):
        bookmark1 = self.setup_bookmark()
        bookmark2 = self.setup_bookmark()
        bookmark3 = self.setup_bookmark()
        tag1 = self.setup_tag()
        tag2 = self.setup_tag()

        tag_bookmarks(
            [bookmark1.id, bookmark3.id],
            f"{tag1.name},{tag2.name}",
            self.get_or_create_test_user(),
        )

        bookmark1.refresh_from_db()
        bookmark2.refresh_from_db()
        bookmark3.refresh_from_db()

        self.assertCountEqual(bookmark1.tags.all(), [tag1, tag2])
        self.assertCountEqual(bookmark2.tags.all(), [])
        self.assertCountEqual(bookmark3.tags.all(), [tag1, tag2])

    def test_tag_bookmarks_should_only_tag_user_owned_bookmarks(self):
        other_user = self.setup_user()
        bookmark1 = self.setup_bookmark()
        bookmark2 = self.setup_bookmark()
        inaccessible_bookmark = self.setup_bookmark(user=other_user)
        tag1 = self.setup_tag()
        tag2 = self.setup_tag()

        tag_bookmarks(
            [bookmark1.id, bookmark2.id, inaccessible_bookmark.id],
            f"{tag1.name},{tag2.name}",
            self.get_or_create_test_user(),
        )

        bookmark1.refresh_from_db()
        bookmark2.refresh_from_db()
        inaccessible_bookmark.refresh_from_db()

        self.assertCountEqual(bookmark1.tags.all(), [tag1, tag2])
        self.assertCountEqual(bookmark2.tags.all(), [tag1, tag2])
        self.assertCountEqual(inaccessible_bookmark.tags.all(), [])

    def test_tag_bookmarks_should_accept_mix_of_int_and_string_ids(self):
        bookmark1 = self.setup_bookmark()
        bookmark2 = self.setup_bookmark()
        bookmark3 = self.setup_bookmark()
        tag1 = self.setup_tag()
        tag2 = self.setup_tag()

        tag_bookmarks(
            [str(bookmark1.id), bookmark2.id, str(bookmark3.id)],
            f"{tag1.name},{tag2.name}",
            self.get_or_create_test_user(),
        )

        self.assertCountEqual(bookmark1.tags.all(), [tag1, tag2])
        self.assertCountEqual(bookmark2.tags.all(), [tag1, tag2])
        self.assertCountEqual(bookmark3.tags.all(), [tag1, tag2])

    def test_untag_bookmarks(self):
        tag1 = self.setup_tag()
        tag2 = self.setup_tag()
        bookmark1 = self.setup_bookmark(tags=[tag1, tag2])
        bookmark2 = self.setup_bookmark(tags=[tag1, tag2])
        bookmark3 = self.setup_bookmark(tags=[tag1, tag2])

        untag_bookmarks(
            [bookmark1.id, bookmark2.id, bookmark3.id],
            f"{tag1.name},{tag2.name}",
            self.get_or_create_test_user(),
        )

        bookmark1.refresh_from_db()
        bookmark2.refresh_from_db()
        bookmark3.refresh_from_db()

        self.assertCountEqual(bookmark1.tags.all(), [])
        self.assertCountEqual(bookmark2.tags.all(), [])
        self.assertCountEqual(bookmark3.tags.all(), [])

    def test_untag_bookmarks_should_only_tag_specified_bookmarks(self):
        tag1 = self.setup_tag()
        tag2 = self.setup_tag()
        bookmark1 = self.setup_bookmark(tags=[tag1, tag2])
        bookmark2 = self.setup_bookmark(tags=[tag1, tag2])
        bookmark3 = self.setup_bookmark(tags=[tag1, tag2])

        untag_bookmarks(
            [bookmark1.id, bookmark3.id],
            f"{tag1.name},{tag2.name}",
            self.get_or_create_test_user(),
        )

        bookmark1.refresh_from_db()
        bookmark2.refresh_from_db()
        bookmark3.refresh_from_db()

        self.assertCountEqual(bookmark1.tags.all(), [])
        self.assertCountEqual(bookmark2.tags.all(), [tag1, tag2])
        self.assertCountEqual(bookmark3.tags.all(), [])

    def test_untag_bookmarks_should_only_tag_user_owned_bookmarks(self):
        other_user = self.setup_user()
        tag1 = self.setup_tag()
        tag2 = self.setup_tag()
        bookmark1 = self.setup_bookmark(tags=[tag1, tag2])
        bookmark2 = self.setup_bookmark(tags=[tag1, tag2])
        inaccessible_bookmark = self.setup_bookmark(user=other_user, tags=[tag1, tag2])

        untag_bookmarks(
            [bookmark1.id, bookmark2.id, inaccessible_bookmark.id],
            f"{tag1.name},{tag2.name}",
            self.get_or_create_test_user(),
        )

        bookmark1.refresh_from_db()
        bookmark2.refresh_from_db()
        inaccessible_bookmark.refresh_from_db()

        self.assertCountEqual(bookmark1.tags.all(), [])
        self.assertCountEqual(bookmark2.tags.all(), [])
        self.assertCountEqual(inaccessible_bookmark.tags.all(), [tag1, tag2])

    def test_untag_bookmarks_should_accept_mix_of_int_and_string_ids(self):
        tag1 = self.setup_tag()
        tag2 = self.setup_tag()
        bookmark1 = self.setup_bookmark(tags=[tag1, tag2])
        bookmark2 = self.setup_bookmark(tags=[tag1, tag2])
        bookmark3 = self.setup_bookmark(tags=[tag1, tag2])

        untag_bookmarks(
            [str(bookmark1.id), bookmark2.id, str(bookmark3.id)],
            f"{tag1.name},{tag2.name}",
            self.get_or_create_test_user(),
        )

        self.assertCountEqual(bookmark1.tags.all(), [])
        self.assertCountEqual(bookmark2.tags.all(), [])
        self.assertCountEqual(bookmark3.tags.all(), [])

    def test_mark_bookmarks_as_read(self):
        bookmark1 = self.setup_bookmark(unread=True)
        bookmark2 = self.setup_bookmark(unread=True)
        bookmark3 = self.setup_bookmark(unread=True)

        mark_bookmarks_as_read(
            [bookmark1.id, bookmark2.id, bookmark3.id], self.get_or_create_test_user()
        )

        self.assertFalse(Bookmark.objects.get(id=bookmark1.id).unread)
        self.assertFalse(Bookmark.objects.get(id=bookmark2.id).unread)
        self.assertFalse(Bookmark.objects.get(id=bookmark3.id).unread)

    def test_mark_bookmarks_as_read_should_only_update_specified_bookmarks(self):
        bookmark1 = self.setup_bookmark(unread=True)
        bookmark2 = self.setup_bookmark(unread=True)
        bookmark3 = self.setup_bookmark(unread=True)

        mark_bookmarks_as_read(
            [bookmark1.id, bookmark3.id], self.get_or_create_test_user()
        )

        self.assertFalse(Bookmark.objects.get(id=bookmark1.id).unread)
        self.assertTrue(Bookmark.objects.get(id=bookmark2.id).unread)
        self.assertFalse(Bookmark.objects.get(id=bookmark3.id).unread)

    def test_mark_bookmarks_as_read_should_only_update_user_owned_bookmarks(self):
        other_user = self.setup_user()
        bookmark1 = self.setup_bookmark(unread=True)
        bookmark2 = self.setup_bookmark(unread=True)
        inaccessible_bookmark = self.setup_bookmark(unread=True, user=other_user)

        mark_bookmarks_as_read(
            [bookmark1.id, bookmark2.id, inaccessible_bookmark.id],
            self.get_or_create_test_user(),
        )

        self.assertFalse(Bookmark.objects.get(id=bookmark1.id).unread)
        self.assertFalse(Bookmark.objects.get(id=bookmark2.id).unread)
        self.assertTrue(Bookmark.objects.get(id=inaccessible_bookmark.id).unread)

    def test_mark_bookmarks_as_read_should_accept_mix_of_int_and_string_ids(self):
        bookmark1 = self.setup_bookmark(unread=True)
        bookmark2 = self.setup_bookmark(unread=True)
        bookmark3 = self.setup_bookmark(unread=True)

        mark_bookmarks_as_read(
            [str(bookmark1.id), bookmark2.id, str(bookmark3.id)],
            self.get_or_create_test_user(),
        )

        self.assertFalse(Bookmark.objects.get(id=bookmark1.id).unread)
        self.assertFalse(Bookmark.objects.get(id=bookmark2.id).unread)
        self.assertFalse(Bookmark.objects.get(id=bookmark3.id).unread)

    def test_mark_bookmarks_as_unread(self):
        bookmark1 = self.setup_bookmark(unread=False)
        bookmark2 = self.setup_bookmark(unread=False)
        bookmark3 = self.setup_bookmark(unread=False)

        mark_bookmarks_as_unread(
            [bookmark1.id, bookmark2.id, bookmark3.id], self.get_or_create_test_user()
        )

        self.assertTrue(Bookmark.objects.get(id=bookmark1.id).unread)
        self.assertTrue(Bookmark.objects.get(id=bookmark2.id).unread)
        self.assertTrue(Bookmark.objects.get(id=bookmark3.id).unread)

    def test_mark_bookmarks_as_unread_should_only_update_specified_bookmarks(self):
        bookmark1 = self.setup_bookmark(unread=False)
        bookmark2 = self.setup_bookmark(unread=False)
        bookmark3 = self.setup_bookmark(unread=False)

        mark_bookmarks_as_unread(
            [bookmark1.id, bookmark3.id], self.get_or_create_test_user()
        )

        self.assertTrue(Bookmark.objects.get(id=bookmark1.id).unread)
        self.assertFalse(Bookmark.objects.get(id=bookmark2.id).unread)
        self.assertTrue(Bookmark.objects.get(id=bookmark3.id).unread)

    def test_mark_bookmarks_as_unread_should_only_update_user_owned_bookmarks(self):
        other_user = self.setup_user()
        bookmark1 = self.setup_bookmark(unread=False)
        bookmark2 = self.setup_bookmark(unread=False)
        inaccessible_bookmark = self.setup_bookmark(unread=False, user=other_user)

        mark_bookmarks_as_unread(
            [bookmark1.id, bookmark2.id, inaccessible_bookmark.id],
            self.get_or_create_test_user(),
        )

        self.assertTrue(Bookmark.objects.get(id=bookmark1.id).unread)
        self.assertTrue(Bookmark.objects.get(id=bookmark2.id).unread)
        self.assertFalse(Bookmark.objects.get(id=inaccessible_bookmark.id).unread)

    def test_mark_bookmarks_as_unread_should_accept_mix_of_int_and_string_ids(self):
        bookmark1 = self.setup_bookmark(unread=False)
        bookmark2 = self.setup_bookmark(unread=False)
        bookmark3 = self.setup_bookmark(unread=False)

        mark_bookmarks_as_unread(
            [str(bookmark1.id), bookmark2.id, str(bookmark3.id)],
            self.get_or_create_test_user(),
        )

        self.assertTrue(Bookmark.objects.get(id=bookmark1.id).unread)
        self.assertTrue(Bookmark.objects.get(id=bookmark2.id).unread)
        self.assertTrue(Bookmark.objects.get(id=bookmark3.id).unread)

    def test_share_bookmarks(self):
        bookmark1 = self.setup_bookmark(shared=False)
        bookmark2 = self.setup_bookmark(shared=False)
        bookmark3 = self.setup_bookmark(shared=False)

        share_bookmarks(
            [bookmark1.id, bookmark2.id, bookmark3.id], self.get_or_create_test_user()
        )

        self.assertTrue(Bookmark.objects.get(id=bookmark1.id).shared)
        self.assertTrue(Bookmark.objects.get(id=bookmark2.id).shared)
        self.assertTrue(Bookmark.objects.get(id=bookmark3.id).shared)

    def test_share_bookmarks_should_only_update_specified_bookmarks(self):
        bookmark1 = self.setup_bookmark(shared=False)
        bookmark2 = self.setup_bookmark(shared=False)
        bookmark3 = self.setup_bookmark(shared=False)

        share_bookmarks([bookmark1.id, bookmark3.id], self.get_or_create_test_user())

        self.assertTrue(Bookmark.objects.get(id=bookmark1.id).shared)
        self.assertFalse(Bookmark.objects.get(id=bookmark2.id).shared)
        self.assertTrue(Bookmark.objects.get(id=bookmark3.id).shared)

    def test_share_bookmarks_should_only_update_user_owned_bookmarks(self):
        other_user = self.setup_user()
        bookmark1 = self.setup_bookmark(shared=False)
        bookmark2 = self.setup_bookmark(shared=False)
        inaccessible_bookmark = self.setup_bookmark(shared=False, user=other_user)

        share_bookmarks(
            [bookmark1.id, bookmark2.id, inaccessible_bookmark.id],
            self.get_or_create_test_user(),
        )

        self.assertTrue(Bookmark.objects.get(id=bookmark1.id).shared)
        self.assertTrue(Bookmark.objects.get(id=bookmark2.id).shared)
        self.assertFalse(Bookmark.objects.get(id=inaccessible_bookmark.id).shared)

    def test_share_bookmarks_should_accept_mix_of_int_and_string_ids(self):
        bookmark1 = self.setup_bookmark(shared=False)
        bookmark2 = self.setup_bookmark(shared=False)
        bookmark3 = self.setup_bookmark(shared=False)

        share_bookmarks(
            [str(bookmark1.id), bookmark2.id, str(bookmark3.id)],
            self.get_or_create_test_user(),
        )

        self.assertTrue(Bookmark.objects.get(id=bookmark1.id).shared)
        self.assertTrue(Bookmark.objects.get(id=bookmark2.id).shared)
        self.assertTrue(Bookmark.objects.get(id=bookmark3.id).shared)

    def test_unshare_bookmarks(self):
        bookmark1 = self.setup_bookmark(shared=True)
        bookmark2 = self.setup_bookmark(shared=True)
        bookmark3 = self.setup_bookmark(shared=True)

        unshare_bookmarks(
            [bookmark1.id, bookmark2.id, bookmark3.id], self.get_or_create_test_user()
        )

        self.assertFalse(Bookmark.objects.get(id=bookmark1.id).shared)
        self.assertFalse(Bookmark.objects.get(id=bookmark2.id).shared)
        self.assertFalse(Bookmark.objects.get(id=bookmark3.id).shared)

    def test_unshare_bookmarks_should_only_update_specified_bookmarks(self):
        bookmark1 = self.setup_bookmark(shared=True)
        bookmark2 = self.setup_bookmark(shared=True)
        bookmark3 = self.setup_bookmark(shared=True)

        unshare_bookmarks([bookmark1.id, bookmark3.id], self.get_or_create_test_user())

        self.assertFalse(Bookmark.objects.get(id=bookmark1.id).shared)
        self.assertTrue(Bookmark.objects.get(id=bookmark2.id).shared)
        self.assertFalse(Bookmark.objects.get(id=bookmark3.id).shared)

    def test_unshare_bookmarks_should_only_update_user_owned_bookmarks(self):
        other_user = self.setup_user()
        bookmark1 = self.setup_bookmark(shared=True)
        bookmark2 = self.setup_bookmark(shared=True)
        inaccessible_bookmark = self.setup_bookmark(shared=True, user=other_user)

        unshare_bookmarks(
            [bookmark1.id, bookmark2.id, inaccessible_bookmark.id],
            self.get_or_create_test_user(),
        )

        self.assertFalse(Bookmark.objects.get(id=bookmark1.id).shared)
        self.assertFalse(Bookmark.objects.get(id=bookmark2.id).shared)
        self.assertTrue(Bookmark.objects.get(id=inaccessible_bookmark.id).shared)

    def test_unshare_bookmarks_should_accept_mix_of_int_and_string_ids(self):
        bookmark1 = self.setup_bookmark(shared=True)
        bookmark2 = self.setup_bookmark(shared=True)
        bookmark3 = self.setup_bookmark(shared=True)

        unshare_bookmarks(
            [str(bookmark1.id), bookmark2.id, str(bookmark3.id)],
            self.get_or_create_test_user(),
        )

        self.assertFalse(Bookmark.objects.get(id=bookmark1.id).shared)
        self.assertFalse(Bookmark.objects.get(id=bookmark2.id).shared)
        self.assertFalse(Bookmark.objects.get(id=bookmark3.id).shared)

    def test_enhance_with_website_metadata(self):
        bookmark = self.setup_bookmark(url="https://example.com")
        with patch.object(
            website_loader, "load_website_metadata"
        ) as mock_load_website_metadata:
            mock_load_website_metadata.return_value = website_loader.WebsiteMetadata(
                url="https://example.com",
                title="Website title",
                description="Website description",
                preview_image=None,
            )

            # missing title and description
            bookmark.title = ""
            bookmark.description = ""
            bookmark.save()
            enhance_with_website_metadata(bookmark)
            bookmark.refresh_from_db()

            self.assertEqual("Website title", bookmark.title)
            self.assertEqual("Website description", bookmark.description)

            # missing title only
            bookmark.title = ""
            bookmark.description = "Initial description"
            bookmark.save()
            enhance_with_website_metadata(bookmark)
            bookmark.refresh_from_db()

            self.assertEqual("Website title", bookmark.title)
            self.assertEqual("Initial description", bookmark.description)

            # missing description only
            bookmark.title = "Initial title"
            bookmark.description = ""
            bookmark.save()
            enhance_with_website_metadata(bookmark)
            bookmark.refresh_from_db()

            self.assertEqual("Initial title", bookmark.title)
            self.assertEqual("Website description", bookmark.description)

            # metadata returns None
            mock_load_website_metadata.return_value = website_loader.WebsiteMetadata(
                url="https://example.com",
                title=None,
                description=None,
                preview_image=None,
            )
            bookmark.title = ""
            bookmark.description = ""
            bookmark.save()
            enhance_with_website_metadata(bookmark)
            bookmark.refresh_from_db()

            self.assertEqual("", bookmark.title)
            self.assertEqual("", bookmark.description)

    def test_refresh_bookmarks_metadata(self):
        bookmark1 = self.setup_bookmark()
        bookmark2 = self.setup_bookmark()
        bookmark3 = self.setup_bookmark()

        refresh_bookmarks_metadata(
            [bookmark1.id, bookmark2.id, bookmark3.id], self.get_or_create_test_user()
        )

        self.assertEqual(self.mock_schedule_refresh_metadata.call_count, 3)
        self.assertEqual(self.mock_load_preview_image.call_count, 3)

    def test_refresh_bookmarks_metadata_should_only_refresh_specified_bookmarks(self):
        bookmark1 = self.setup_bookmark()
        bookmark2 = self.setup_bookmark()
        bookmark3 = self.setup_bookmark()

        refresh_bookmarks_metadata(
            [bookmark1.id, bookmark3.id], self.get_or_create_test_user()
        )

        self.assertEqual(self.mock_schedule_refresh_metadata.call_count, 2)
        self.assertEqual(self.mock_load_preview_image.call_count, 2)

        for call_args in self.mock_schedule_refresh_metadata.call_args_list:
            args, kwargs = call_args
            self.assertNotIn(bookmark2.id, args)

        for call_args in self.mock_load_preview_image.call_args_list:
            args, kwargs = call_args
            self.assertNotIn(bookmark2.id, args)

    def test_refresh_bookmarks_metadata_should_only_refresh_user_owned_bookmarks(self):
        other_user = self.setup_user()
        bookmark1 = self.setup_bookmark()
        bookmark2 = self.setup_bookmark()
        inaccessible_bookmark = self.setup_bookmark(user=other_user)

        refresh_bookmarks_metadata(
            [bookmark1.id, bookmark2.id, inaccessible_bookmark.id],
            self.get_or_create_test_user(),
        )

        self.assertEqual(self.mock_schedule_refresh_metadata.call_count, 2)
        self.assertEqual(self.mock_load_preview_image.call_count, 2)

        for call_args in self.mock_schedule_refresh_metadata.call_args_list:
            args, kwargs = call_args
            self.assertNotIn(inaccessible_bookmark.id, args)

        for call_args in self.mock_load_preview_image.call_args_list:
            args, kwargs = call_args
            self.assertNotIn(inaccessible_bookmark.id, args)

    def test_refresh_bookmarks_metadata_should_accept_mix_of_int_and_string_ids(self):
        bookmark1 = self.setup_bookmark()
        bookmark2 = self.setup_bookmark()
        bookmark3 = self.setup_bookmark()

        refresh_bookmarks_metadata(
            [str(bookmark1.id), str(bookmark2.id), bookmark3.id],
            self.get_or_create_test_user(),
        )

        self.assertEqual(self.mock_schedule_refresh_metadata.call_count, 3)
        self.assertEqual(self.mock_load_preview_image.call_count, 3)

    def test_create_html_snapshots(self):
        with patch.object(tasks, "create_html_snapshots") as mock_create_html_snapshots:
            bookmark1 = self.setup_bookmark()
            bookmark2 = self.setup_bookmark()
            bookmark3 = self.setup_bookmark()

            create_html_snapshots(
                [bookmark1.id, bookmark2.id, bookmark3.id],
                self.get_or_create_test_user(),
            )

            mock_create_html_snapshots.assert_called_once()
            call_args = mock_create_html_snapshots.call_args[0][0]
            bookmark_ids = list(call_args.values_list("id", flat=True))
            self.assertCountEqual(
                bookmark_ids, [bookmark1.id, bookmark2.id, bookmark3.id]
            )

    def test_create_html_snapshots_should_only_create_for_specified_bookmarks(self):
        with patch.object(tasks, "create_html_snapshots") as mock_create_html_snapshots:
            bookmark1 = self.setup_bookmark()
            bookmark2 = self.setup_bookmark()
            bookmark3 = self.setup_bookmark()

            create_html_snapshots(
                [bookmark1.id, bookmark3.id], self.get_or_create_test_user()
            )

            mock_create_html_snapshots.assert_called_once()
            call_args = mock_create_html_snapshots.call_args[0][0]
            bookmark_ids = list(call_args.values_list("id", flat=True))
            self.assertCountEqual(bookmark_ids, [bookmark1.id, bookmark3.id])
            self.assertNotIn(bookmark2.id, bookmark_ids)

    def test_create_html_snapshots_should_only_create_for_user_owned_bookmarks(self):
        with patch.object(tasks, "create_html_snapshots") as mock_create_html_snapshots:
            other_user = self.setup_user()
            bookmark1 = self.setup_bookmark()
            bookmark2 = self.setup_bookmark()
            inaccessible_bookmark = self.setup_bookmark(user=other_user)

            create_html_snapshots(
                [bookmark1.id, bookmark2.id, inaccessible_bookmark.id],
                self.get_or_create_test_user(),
            )

            mock_create_html_snapshots.assert_called_once()
            call_args = mock_create_html_snapshots.call_args[0][0]
            bookmark_ids = list(call_args.values_list("id", flat=True))
            self.assertCountEqual(bookmark_ids, [bookmark1.id, bookmark2.id])
            self.assertNotIn(inaccessible_bookmark.id, bookmark_ids)

    def test_create_html_snapshots_should_accept_mix_of_int_and_string_ids(self):
        with patch.object(tasks, "create_html_snapshots") as mock_create_html_snapshots:
            bookmark1 = self.setup_bookmark()
            bookmark2 = self.setup_bookmark()
            bookmark3 = self.setup_bookmark()

            create_html_snapshots(
                [str(bookmark1.id), bookmark2.id, str(bookmark3.id)],
                self.get_or_create_test_user(),
            )

            mock_create_html_snapshots.assert_called_once()
            call_args = mock_create_html_snapshots.call_args[0][0]
            bookmark_ids = list(call_args.values_list("id", flat=True))
            self.assertCountEqual(
                bookmark_ids, [bookmark1.id, bookmark2.id, bookmark3.id]
            )


================================================
FILE: bookmarks/tests/test_bookmarks_tasks.py
================================================
from unittest import mock

import waybackpy
from django.contrib.auth.models import User
from django.test import TestCase, override_settings
from huey.contrib.djhuey import HUEY as huey
from waybackpy.exceptions import WaybackError

from bookmarks.models import BookmarkAsset, UserProfile
from bookmarks.services import tasks
from bookmarks.services.website_loader import WebsiteMetadata
from bookmarks.tests.helpers import BookmarkFactoryMixin


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)

    if fail_on_save:
        mock_api.save.side_effect = WaybackError

    return mock_api


class BookmarkTasksTestCase(TestCase, BookmarkFactoryMixin):
    def setUp(self):
        huey.immediate = True
        huey.results = True
        huey.store_none = True

        self.mock_save_api = mock.Mock(
            archive_url="https://example.com/created_snapshot"
        )
        self.mock_save_api_patcher = mock.patch.object(
            waybackpy, "WaybackMachineSaveAPI", return_value=self.mock_save_api
        )
        self.mock_save_api_patcher.start()

        self.mock_load_favicon_patcher = mock.patch(
            "bookmarks.services.favicon_loader.load_favicon"
        )
        self.mock_load_favicon = self.mock_load_favicon_patcher.start()
        self.mock_load_favicon.return_value = "https_example_com.png"

        self.mock_assets_create_snapshot_patcher = mock.patch(
            "bookmarks.services.assets.create_snapshot",
        )
        self.mock_assets_create_snapshot = (
            self.mock_assets_create_snapshot_patcher.start()
        )

        self.mock_load_preview_image_patcher = mock.patch(
            "bookmarks.services.preview_image_loader.load_preview_image"
        )
        self.mock_load_preview_image = self.mock_load_preview_image_patcher.start()
        self.mock_load_preview_image.return_value = "preview_image.png"

        user = self.get_or_create_test_user()
        user.profile.web_archive_integration = (
            UserProfile.WEB_ARCHIVE_INTEGRATION_ENABLED
        )
        user.profile.enable_favicons = True
        user.profile.enable_preview_images = True
        user.profile.save()

    def tearDown(self):
        self.mock_save_api_patcher.stop()
        self.mock_load_favicon_patcher.stop()
        self.mock_assets_create_snapshot_patcher.stop()
        self.mock_load_preview_image_patcher.stop()
        huey.storage.flush_results()
        huey.immediate = False

    def executed_count(self):
        return len(huey.all_results())

    def test_create_web_archive_snapshot_should_update_snapshot_url(self):
        bookmark = self.setup_bookmark()

        tasks.create_web_archive_snapshot(
            self.get_or_create_test_user(), bookmark, False
        )
        bookmark.refresh_from_db()

        self.mock_save_api.save.assert_called_once()
        self.assertEqual(self.executed_count(), 1)
        self.assertEqual(
            bookmark.web_archive_snapshot_url,
            "https://example.com/created_snapshot",
        )

    def test_create_web_archive_snapshot_should_handle_missing_bookmark_id(self):
        tasks._create_web_archive_snapshot_task(123, False)

        self.assertEqual(self.executed_count(), 1)
        self.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")

        self.mock_save_api.create_web_archive_snapshot(
            self.get_or_create_test_user(), bookmark, False
        )

        self.assertEqual(self.executed_count(), 0)
        self.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")
        self.mock_save_api.archive_url = "https://other.com"

        tasks.create_web_archive_snapshot(
            self.get_or_create_test_user(), bookmark, True
        )
        bookmark.refresh_from_db()

        self.assertEqual(bookmark.web_archive_snapshot_url, "https://other.com")

    def test_create_web_archive_snapshot_should_not_save_stale_bookmark_data(self):
        bookmark = self.setup_bookmark()

        # 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()

        self.mock_save_api.save.side_effect = mock_save_impl

        tasks.create_web_archive_snapshot(
            self.get_or_create_test_user(), bookmark, False
        )
        bookmark.refresh_from_db()

        self.assertEqual(bookmark.title, "Updated title")
        self.assertEqual(
            "https://example.com/created_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()

        tasks.create_web_archive_snapshot(
            self.get_or_create_test_user(), bookmark, False
        )
        self.assertEqual(self.executed_count(), 0)

    def test_create_web_archive_snapshot_should_not_run_when_web_archive_integration_is_disabled(
        self,
    ):
        self.user.profile.web_archive_integration = (
            UserProfile.WEB_ARCHIVE_INTEGRATION_DISABLED
        )
        self.user.profile.save()

        bookmark = self.setup_bookmark()
        tasks.create_web_archive_snapshot(
            self.get_or_create_test_user(), bookmark, False
        )

        self.assertEqual(self.executed_count(), 0)

    def test_load_favicon_should_create_favicon_file(self):
        bookmark = self.setup_bookmark()

        tasks.load_favicon(self.get_or_create_test_user(), bookmark)
        bookmark.refresh_from_db()

        self.assertEqual(self.executed_count(), 1)
        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")

        self.mock_load_favicon.return_value = "https_example_updated_com.png"

        tasks.load_favicon(self.get_or_create_test_user(), bookmark)

        bookmark.refresh_from_db()
        self.mock_load_favicon.assert_called_once()
        self.assertEqual(bookmark.favicon_file, "https_example_updated_com.png")

    def test_load_favicon_should_handle_missing_bookmark(self):
        tasks._load_favicon_task(123)

        self.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"

        self.mock_load_favicon.side_effect = mock_load_favicon_impl

        tasks.load_favicon(self.get_or_create_test_user(), bookmark)
        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(self.executed_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(self.executed_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.assertEqual(self.executed_count(), 4)
        self.assertEqual(self.mock_load_favicon.call_count, 3)

    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.assertEqual(self.mock_load_favicon.call_count, 3)

    @override_settings(LD_DISABLE_BACKGROUND_TASKS=True)
    def test_schedule_bookmarks_without_favicons_should_not_run_when_background_tasks_are_disabled(
        self,
    ):
        self.setup_bookmark()
        tasks.schedule_bookmarks_without_favicons(self.get_or_create_test_user())

        self.assertEqual(self.executed_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()

        self.setup_bookmark()
        tasks.schedule_bookmarks_without_favicons(self.get_or_create_test_user())

        self.assertEqual(self.executed_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.assertEqual(self.executed_count(), 7)
        self.assertEqual(self.mock_load_favicon.call_count, 6)

    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.assertEqual(self.mock_load_favicon.call_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(self.executed_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(self.executed_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(self.executed_count(), 0)

    def test_load_preview_image_should_create_preview_image_file(self):
        bookmark = self.setup_bookmark()

        tasks.load_preview_image(self.get_or_create_test_user(), bookmark)
        bookmark.refresh_from_db()

        self.assertEqual(self.executed_count(), 1)
        self.assertEqual(bookmark.preview_image_file, "preview_image.png")

    def test_load_preview_image_should_update_preview_image_file(self):
        bookmark = self.setup_bookmark(
            preview_image_file="preview_image.png",
        )

        self.mock_load_preview_image.return_value = "preview_image_upd.png"

        tasks.load_preview_image(self.get_or_create_test_user(), bookmark)

        bookmark.refresh_from_db()
        self.mock_load_preview_image.assert_called_once()
        self.assertEqual(bookmark.preview_image_file, "preview_image_upd.png")

    def test_load_preview_image_should_set_blank_when_none_is_returned(self):
        bookmark = self.setup_bookmark(
            preview_image_file="preview_image.png",
        )

        self.mock_load_preview_image.return_value = None

        tasks.load_preview_image(self.get_or_create_test_user(), bookmark)

        bookmark.refresh_from_db()
        self.mock_load_preview_image.assert_called_once()
        self.assertEqual(bookmark.preview_image_file, "")

    def test_load_preview_image_should_handle_missing_bookmark(self):
        tasks._load_preview_image_task(123)

        self.mock_load_preview_image.assert_not_called()

    def test_load_preview_image_should_not_save_stale_bookmark_data(self):
        bookmark = self.setup_bookmark()

        # update bookmark during API call to check that saving
        # the image does not overwrite updated bookmark data
        def mock_load_preview_image_impl(url):
            bookmark.title = "Updated title"
            bookmark.save()
            return "test.png"

        self.mock_load_preview_image.side_effect = mock_load_preview_image_impl

        tasks.load_preview_image(self.get_or_create_test_user(), bookmark)
        bookmark.refresh_from_db()

        self.assertEqual(bookmark.title, "Updated title")
        self.assertEqual(bookmark.preview_image_file, "test.png")

    @override_settings(LD_DISABLE_BACKGROUND_TASKS=True)
    def test_load_preview_image_should_not_run_when_background_tasks_are_disabled(self):
        bookmark = self.setup_bookmark()
        tasks.load_preview_image(self.get_or_create_test_user(), bookmark)

        self.assertEqual(self.executed_count(), 0)

    def test_load_preview_image_should_not_run_when_preview_image_feature_is_disabled(
        self,
    ):
        self.user.profile.enable_preview_images = False
        self.user.profile.save()

        bookmark = self.setup_bookmark()
        tasks.load_preview_image(self.get_or_create_test_user(), bookmark)

        self.assertEqual(self.executed_count(), 0)

    def test_schedule_bookmarks_without_previews_should_load_preview_for_all_bookmarks_without_preview(
        self,
    ):
        user = self.get_or_create_test_user()
        self.setup_bookmark()
        self.setup_bookmark()
        self.setup_bookmark()
        self.setup_bookmark(preview_image_file="test.png")
        self.setup_bookmark(preview_image_file="test.png")
        self.setup_bookmark(preview_image_file="test.png")

        tasks.schedule_bookmarks_without_previews(user)

        self.assertEqual(self.executed_count(), 4)
        self.assertEqual(self.mock_load_preview_image.call_count, 3)

    def test_schedule_bookmarks_without_previews_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_previews(user)

        self.assertEqual(self.mock_load_preview_image.call_count, 3)

    @override_settings(LD_DISABLE_BACKGROUND_TASKS=True)
    def test_schedule_bookmarks_without_previews_should_not_run_when_background_tasks_are_disabled(
        self,
    ):
        self.setup_bookmark()
        tasks.schedule_bookmarks_without_previews(self.get_or_create_test_user())

        self.assertEqual(self.executed_count(), 0)

    def test_schedule_bookmarks_without_previews_should_not_run_when_preview_feature_is_disabled(
        self,
    ):
        self.user.profile.enable_preview_images = False
        self.user.profile.save()

        self.setup_bookmark()
        tasks.schedule_bookmarks_without_previews(self.get_or_create_test_user())

        self.assertEqual(self.executed_count(), 0)

    @override_settings(LD_ENABLE_SNAPSHOTS=True)
    def test_create_html_snapshot_should_create_pending_asset(self):
        bookmark = self.setup_bookmark()

        # Mock the task function to avoid running it immediately
        with mock.patch("bookmarks.services.tasks._create_html_snapshot_task"):
            tasks.create_html_snapshot(bookmark)
            self.assertEqual(BookmarkAsset.objects.count(), 1)

            tasks.create_html_snapshot(bookmark)
            self.assertEqual(BookmarkAsset.objects.count(), 2)

            assets = BookmarkAsset.objects.filter(bookmark=bookmark)
            for asset in assets:
                self.assertEqual(asset.bookmark, bookmark)
                self.assertEqual(asset.asset_type, BookmarkAsset.TYPE_SNAPSHOT)
                self.assertEqual(asset.content_type, "")
                self.assertIn("New snapshot", asset.display_name)
                self.assertEqual(asset.status, BookmarkAsset.STATUS_PENDING)

            self.mock_assets_create_snapshot.assert_not_called()

    @override_settings(LD_ENABLE_SNAPSHOTS=True)
    def test_schedule_html_snapshots_should_create_snapshots(self):
        bookmark = self.setup_bookmark(url="https://example.com")

        tasks.create_html_snapshot(bookmark)
        tasks.create_html_snapshot(bookmark)
        tasks.create_html_snapshot(bookmark)

        assets = BookmarkAsset.objects.filter(bookmark=bookmark)

        tasks._schedule_html_snapshots_task()

        # should call create_snapshot for each pending asset
        self.assertEqual(self.mock_assets_create_snapshot.call_count, 3)

        for asset in assets:
            self.mock_assets_create_snapshot.assert_any_call(asset)

    @override_settings(LD_ENABLE_SNAPSHOTS=True)
    def test_create_html_snapshot_should_handle_missing_asset(self):
        tasks._create_html_snapshot_task(123)

        self.mock_assets_create_snapshot.assert_not_called()

    @override_settings(LD_ENABLE_SNAPSHOTS=False)
    def test_create_html_snapshot_should_not_create_asset_when_single_file_is_disabled(
        self,
    ):
        bookmark = self.setup_bookmark()
        tasks.create_html_snapshot(bookmark)

        self.assertEqual(BookmarkAsset.objects.count(), 0)

    @override_settings(LD_ENABLE_SNAPSHOTS=True, LD_DISABLE_BACKGROUND_TASKS=True)
    def test_create_html_snapshot_should_not_create_asset_when_background_tasks_are_disabled(
        self,
    ):
        bookmark = self.setup_bookmark()
        tasks.create_html_snapshot(bookmark)

        self.assertEqual(BookmarkAsset.objects.count(), 0)

    @override_settings(LD_ENABLE_SNAPSHOTS=True)
    def test_create_missing_html_snapshots(self):
        bookmarks_with_snapshots = []
        bookmarks_without_snapshots = []

        # setup bookmarks with snapshots
        bookmark = self.setup_bookmark()
        self.setup_asset(
            bookmark=bookmark,
            asset_type=BookmarkAsset.TYPE_SNAPSHOT,
            status=BookmarkAsset.STATUS_COMPLETE,
        )
        bookmarks_with_snapshots.append(bookmark)

        bookmark = self.setup_bookmark()
        self.setup_asset(
            bookmark=bookmark,
            asset_type=BookmarkAsset.TYPE_SNAPSHOT,
            status=BookmarkAsset.STATUS_PENDING,
        )
        bookmarks_with_snapshots.append(bookmark)

        # setup bookmarks without snapshots
        bookmark = self.setup_bookmark()
        bookmarks_without_snapshots.append(bookmark)

        bookmark = self.setup_bookmark()
        self.setup_asset(
            bookmark=bookmark,
            asset_type=BookmarkAsset.TYPE_SNAPSHOT,
            status=BookmarkAsset.STATUS_FAILURE,
        )
        bookmarks_without_snapshots.append(bookmark)

        bookmark = self.setup_bookmark()
        self.setup_asset(
            bookmark=bookmark,
            asset_type="some_other_type",
            status=BookmarkAsset.STATUS_PENDING,
        )
        bookmarks_without_snapshots.append(bookmark)

        bookmark = self.setup_bookmark()
        self.setup_asset(
            bookmark=bookmark,
            asset_type="some_other_type",
            status=BookmarkAsset.STATUS_COMPLETE,
        )
        bookmarks_without_snapshots.append(bookmark)

        initial_assets = list(BookmarkAsset.objects.all())
        initial_assets_count = len(initial_assets)
        initial_asset_ids = [asset.id for asset in initial_assets]
        count = tasks.create_missing_html_snapshots(self.get_or_create_test_user())

        self.assertEqual(count, 4)
        self.assertEqual(BookmarkAsset.objects.count(), initial_assets_count + count)

        for bookmark in bookmarks_without_snapshots:
            new_assets = BookmarkAsset.objects.filter(bookmark=bookmark).exclude(
                id__in=initial_asset_ids
            )
            self.assertEqual(new_assets.count(), 1)

        for bookmark in bookmarks_with_snapshots:
            new_assets = BookmarkAsset.objects.filter(bookmark=bookmark).exclude(
                id__in=initial_asset_ids
            )
            self.assertEqual(new_assets.count(), 0)

    @override_settings(LD_ENABLE_SNAPSHOTS=True)
    def test_create_missing_html_snapshots_respects_current_user(self):
        self.setup_bookmark()
        self.setup_bookmark()
        self.setup_bookmark()

        other_user = self.setup_user()
        self.setup_bookmark(user=other_user)
        self.setup_bookmark(user=other_user)
        self.setup_bookmark(user=other_user)

        count = tasks.create_missing_html_snapshots(self.get_or_create_test_user())

        self.assertEqual(count, 3)
        self.assertEqual(BookmarkAsset.objects.count(), count)

    @override_settings(LD_DISABLE_BACKGROUND_TASKS=True)
    def test_refresh_metadata_task_not_called_when_background_tasks_disabled(self):
        bookmark = self.setup_bookmark()
        with mock.patch(
            "bookmarks.services.tasks._refresh_metadata_task"
        ) as mock_refresh_metadata_task:
            tasks.refresh_metadata(bookmark)
            mock_refresh_metadata_task.assert_not_called()

    @override_settings(LD_DISABLE_BACKGROUND_TASKS=False)
    def test_refresh_metadata_task_called_when_background_tasks_enabled(self):
        bookmark = self.setup_bookmark()
        with mock.patch(
            "bookmarks.services.tasks._refresh_metadata_task"
        ) as mock_refresh_metadata_task:
            tasks.refresh_metadata(bookmark)
            mock_refresh_metadata_task.assert_called_once()

    def test_refresh_metadata_task_should_handle_missing_bookmark(self):
        with mock.patch(
            "bookmarks.services.website_loader.load_website_metadata"
        ) as mock_load_website_metadata:
            tasks._refresh_metadata_task(123)

            mock_load_website_metadata.assert_not_called()

    def test_refresh_metadata_updates_title_description(self):
        bookmark = self.setup_bookmark(
            title="Initial title",
            description="Initial description",
        )
        mock_website_metadata = WebsiteMetadata(
            url=bookmark.url,
            title="New title",
            description="New description",
            preview_image=None,
        )

        with mock.patch(
            "bookmarks.services.tasks.load_website_metadata"
        ) as mock_load_website_metadata:
            mock_load_website_metadata.return_value = mock_website_metadata

            tasks.refresh_metadata(bookmark)

            bookmark.refresh_from_db()
            self.assertEqual(bookmark.title, "New title")
            self.assertEqual(bookmark.description, "New description")


================================================
FILE: bookmarks/tests/test_bundles_api.py
================================================
from django.urls import reverse
from rest_framework import status

from bookmarks.models import BookmarkBundle
from bookmarks.tests.helpers import BookmarkFactoryMixin, LinkdingApiTestCase


class BundlesApiTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
    def assertBundle(self, bundle: BookmarkBundle, data: dict):
        self.assertEqual(bundle.id, data["id"])
        self.assertEqual(bundle.name, data["name"])
        self.assertEqual(bundle.search, data["search"])
        self.assertEqual(bundle.any_tags, data["any_tags"])
        self.assertEqual(bundle.all_tags, data["all_tags"])
        self.assertEqual(bundle.excluded_tags, data["excluded_tags"])
        self.assertEqual(bundle.filter_unread, data["filter_unread"])
        self.assertEqual(bundle.filter_shared, data["filter_shared"])
        self.assertEqual(bundle.order, data["order"])
        self.assertEqual(
            bundle.date_created.isoformat().replace("+00:00", "Z"), data["date_created"]
        )
        self.assertEqual(
            bundle.date_modified.isoformat().replace("+00:00", "Z"),
            data["date_modified"],
        )

    def test_bundle_list(self):
        self.authenticate()

        bundles = [
            self.setup_bundle(name="Bundle 1", order=0),
            self.setup_bundle(name="Bundle 2", order=1),
            self.setup_bundle(name="Bundle 3", order=2),
        ]

        url = reverse("linkding:bundle-list")
        response = self.get(url, expected_status_code=status.HTTP_200_OK)

        self.assertEqual(len(response.data["results"]), 3)
        self.assertBundle(bundles[0], response.data["results"][0])
        self.assertBundle(bundles[1], response.data["results"][1])
        self.assertBundle(bundles[2], response.data["results"][2])

    def test_bundle_list_only_returns_own_bundles(self):
        self.authenticate()

        user_bundles = [
            self.setup_bundle(name="User Bundle 1"),
            self.setup_bundle(name="User Bundle 2"),
        ]

        other_user = self.setup_user()
        self.setup_bundle(name="Other User Bundle 1", user=other_user)
        self.setup_bundle(name="Other User Bundle 2", user=other_user)

        url = reverse("linkding:bundle-list")
        response = self.get(url, expected_status_code=status.HTTP_200_OK)

        self.assertEqual(len(response.data["results"]), 2)
        self.assertBundle(user_bundles[0], response.data["results"][0])
        self.assertBundle(user_bundles[1], response.data["results"][1])

    def test_bundle_list_requires_authentication(self):
        url = reverse("linkding:bundle-list")
        self.get(url, expected_status_code=status.HTTP_401_UNAUTHORIZED)

    def test_bundle_detail(self):
        self.authenticate()

        bundle = self.setup_bundle(
            name="Test Bundle",
            search="test search",
            any_tags="tag1 tag2",
            all_tags="required-tag",
            excluded_tags="excluded-tag",
            filter_unread=BookmarkBundle.FILTER_STATE_YES,
            filter_shared=BookmarkBundle.FILTER_STATE_NO,
            order=5,
        )

        url = reverse("linkding:bundle-detail", kwargs={"pk": bundle.id})
        response = self.get(url, expected_status_code=status.HTTP_200_OK)

        self.assertBundle(bundle, response.data)

    def test_bundle_detail_only_returns_own_bundles(self):
        self.authenticate()

        other_user = self.setup_user()
        other_bundle = self.setup_bundle(name="Other User Bundle", user=other_user)

        url = reverse("linkding:bundle-detail", kwargs={"pk": other_bundle.id})
        self.get(url, expected_status_code=status.HTTP_404_NOT_FOUND)

    def test_bundle_detail_requires_authentication(self):
        bundle = self.setup_bundle()
        url = reverse("linkding:bundle-detail", kwargs={"pk": bundle.id})
        self.get(url, expected_status_code=status.HTTP_401_UNAUTHORIZED)

    def test_create_bundle(self):
        self.authenticate()

        bundle_data = {
            "name": "New Bundle",
            "search": "test search",
            "any_tags": "tag1 tag2",
            "all_tags": "required-tag",
            "excluded_tags": "excluded-tag",
            "filter_unread": BookmarkBundle.FILTER_STATE_YES,
            "filter_shared": BookmarkBundle.FILTER_STATE_NO,
        }

        url = reverse("linkding:bundle-list")
        response = self.post(
            url, bundle_data, expected_status_code=status.HTTP_201_CREATED
        )

        bundle = BookmarkBundle.objects.get(id=response.data["id"])
        self.assertEqual(bundle.name, bundle_data["name"])
        self.assertEqual(bundle.search, bundle_data["search"])
        self.assertEqual(bundle.any_tags, bundle_data["any_tags"])
        self.assertEqual(bundle.all_tags, bundle_data["all_tags"])
        self.assertEqual(bundle.excluded_tags, bundle_data["excluded_tags"])
        self.assertEqual(bundle.filter_unread, bundle_data["filter_unread"])
        self.assertEqual(bundle.filter_shared, bundle_data["filter_shared"])
        self.assertEqual(bundle.owner, self.user)
        self.assertEqual(bundle.order, 0)

        self.assertBundle(bundle, response.data)

    def test_create_bundle_auto_increments_order(self):
        self.authenticate()

        self.setup_bundle(name="Existing Bundle", order=2)

        bundle_data = {"name": "New Bundle", "search": "test search"}

        url = reverse("linkding:bundle-list")
        response = self.post(
            url, bundle_data, expected_status_code=status.HTTP_201_CREATED
        )

        bundle = BookmarkBundle.objects.get(id=response.data["id"])
        self.assertEqual(bundle.order, 3)

    def test_create_bundle_with_custom_order(self):
        self.authenticate()

        bundle_data = {"name": "New Bundle", "order": 10}

        url = reverse("linkding:bundle-list")
        response = self.post(
            url, bundle_data, expected_status_code=status.HTTP_201_CREATED
        )

        bundle = BookmarkBundle.objects.get(id=response.data["id"])
        self.assertEqual(bundle.order, 10)

    def test_create_bundle_requires_name(self):
        self.authenticate()

        bundle_data = {"search": "test search"}

        url = reverse("linkding:bundle-list")
        self.post(url, bundle_data, expected_status_code=status.HTTP_400_BAD_REQUEST)

    def test_create_bundle_fields_can_be_empty(self):
        self.authenticate()

        bundle_data = {
            "name": "Minimal Bundle",
            "search": "",
            "any_tags": "",
            "all_tags": "",
            "excluded_tags": "",
        }

        url = reverse("linkding:bundle-list")
        response = self.post(
            url, bundle_data, expected_status_code=status.HTTP_201_CREATED
        )

        bundle = BookmarkBundle.objects.get(id=response.data["id"])
        self.assertEqual(bundle.name, "Minimal Bundle")
        self.assertEqual(bundle.search, "")
        self.assertEqual(bundle.any_tags, "")
        self.assertEqual(bundle.all_tags, "")
        self.assertEqual(bundle.excluded_tags, "")

    def test_create_bundle_requires_authentication(self):
        bundle_data = {"name": "New Bundle"}

        url = reverse("linkding:bundle-list")
        self.post(url, bundle_data, expected_status_code=status.HTTP_401_UNAUTHORIZED)

    def test_update_bundle_put(self):
        self.authenticate()

        bundle = self.setup_bundle(
            name="Original Bundle",
            search="original search",
            any_tags="original-tag",
            order=1,
        )

        updated_data = {
            "name": "Updated Bundle",
            "search": "updated search",
            "any_tags": "updated-tag1 updated-tag2",
            "all_tags": "required-updated-tag",
            "excluded_tags": "excluded-updated-tag",
            "filter_unread": BookmarkBundle.FILTER_STATE_YES,
            "filter_shared": BookmarkBundle.FILTER_STATE_NO,
            "order": 5,
        }

        url = reverse("linkding:bundle-detail", kwargs={"pk": bundle.id})
        response = self.put(url, updated_data, expected_status_code=status.HTTP_200_OK)

        bundle.refresh_from_db()
        self.assertEqual(bundle.name, updated_data["name"])
        self.assertEqual(bundle.search, updated_data["search"])
        self.assertEqual(bundle.any_tags, updated_data["any_tags"])
        self.assertEqual(bundle.all_tags, updated_data["all_tags"])
        self.assertEqual(bundle.excluded_tags, updated_data["excluded_tags"])
        self.assertEqual(bundle.filter_unread, updated_data["filter_unread"])
        self.assertEqual(bundle.filter_shared, updated_data["filter_shared"])
        self.assertEqual(bundle.order, updated_data["order"])

        self.assertBundle(bundle, response.data)

    def test_update_bundle_patch(self):
        self.authenticate()

        bundle = self.setup_bundle(
            name="Original Bundle", search="original search", any_tags="original-tag"
        )

        updated_data = {
            "name": "Partially Updated Bundle",
            "search": "partially updated search",
        }

        url = reverse("linkding:bundle-detail", kwargs={"pk": bundle.id})
        response = self.patch(
            url, updated_data, expected_status_code=status.HTTP_200_OK
        )

        bundle.refresh_from_db()
        self.assertEqual(bundle.name, updated_data["name"])
        self.assertEqual(bundle.search, updated_data["search"])
        self.assertEqual(bundle.any_tags, "original-tag")  # Should remain unchanged

        self.assertBundle(bundle, response.data)

    def test_update_bundle_only_allows_own_bundles(self):
        self.authenticate()

        other_user = self.setup_user()
        other_bundle = self.setup_bundle(name="Other User Bundle", user=other_user)

        updated_data = {"name": "Updated Bundle"}

        url = reverse("linkding:bundle-detail", kwargs={"pk": other_bundle.id})
        self.put(url, updated_data, expected_status_code=status.HTTP_404_NOT_FOUND)

    def test_update_bundle_requires_authentication(self):
        bundle = self.setup_bundle()
        updated_data = {"name": "Updated Bundle"}

        url = reverse("linkding:bundle-detail", kwargs={"pk": bundle.id})
        self.put(url, updated_data, expected_status_code=status.HTTP_401_UNAUTHORIZED)

    def test_delete_bundle(self):
        self.authenticate()

        bundle = self.setup_bundle(name="Bundle to Delete")

        url = reverse("linkding:bundle-detail", kwargs={"pk": bundle.id})
        self.delete(url, expected_status_code=status.HTTP_204_NO_CONTENT)

        self.assertFalse(BookmarkBundle.objects.filter(id=bundle.id).exists())

    def test_delete_bundle_updates_order(self):
        self.authenticate()

        bundle1 = self.setup_bundle(name="Bundle 1", order=0)
        bundle2 = self.setup_bundle(name="Bundle 2", order=1)
        bundle3 = self.setup_bundle(name="Bundle 3", order=2)

        url = reverse("linkding:bundle-detail", kwargs={"pk": bundle2.id})
        self.delete(url, expected_status_code=status.HTTP_204_NO_CONTENT)

        self.assertFalse(BookmarkBundle.objects.filter(id=bundle2.id).exists())

        # Check that the remaining bundles have updated orders
        bundle1.refresh_from_db()
        bundle3.refresh_from_db()
        self.assertEqual(bundle1.order, 0)
        self.assertEqual(bundle3.order, 1)

    def test_delete_bundle_only_allows_own_bundles(self):
        self.authenticate()

        other_user = self.setup_user()
        other_bundle = self.setup_bundle(name="Other User Bundle", user=other_user)

        url = reverse("linkding:bundle-detail", kwargs={"pk": other_bundle.id})
        self.delete(url, expected_status_code=status.HTTP_404_NOT_FOUND)

        self.assertTrue(BookmarkBundle.objects.filter(id=other_bundle.id).exists())

    def test_delete_bundle_requires_authentication(self):
        bundle = self.setup_bundle()
        url = reverse("linkding:bundle-detail", kwargs={"pk": bundle.id})
        self.delete(url, expected_status_code=status.HTTP_401_UNAUTHORIZED)

        self.assertTrue(BookmarkBundle.objects.filter(id=bundle.id).exists())

    def test_bundles_ordered_by_order_field(self):
        self.authenticate()

        self.setup_bundle(name="Third Bundle", order=2)
        self.setup_bundle(name="First Bundle", order=0)
        self.setup_bundle(name="Second Bundle", order=1)

        url = reverse("linkding:bundle-list")
        response = self.get(url, expected_status_code=status.HTTP_200_OK)

        self.assertEqual(len(response.data["results"]), 3)
        self.assertEqual(response.data["results"][0]["name"], "First Bundle")
        self.assertEqual(response.data["results"][1]["name"], "Second Bundle")
        self.assertEqual(response.data["results"][2]["name"], "Third Bundle")


================================================
FILE: bookmarks/tests/test_bundles_edit_view.py
================================================
from django.test import TestCase
from django.urls import reverse

from bookmarks.models import BookmarkBundle
from bookmarks.tests.helpers import BookmarkFactoryMixin


class BundleEditViewTestCase(TestCase, BookmarkFactoryMixin):
    def setUp(self) -> None:
        user = self.get_or_create_test_user()
        self.client.force_login(user)

    def create_form_data(self, overrides=None):
        if overrides is None:
            overrides = {}
        form_data = {
            "name": "Test Bundle",
            "search": "test search",
            "any_tags": "tag1 tag2",
            "all_tags": "required-tag",
            "excluded_tags": "excluded-tag",
            "filter_unread": BookmarkBundle.FILTER_STATE_YES,
            "filter_shared": BookmarkBundle.FILTER_STATE_NO,
        }
        return {**form_data, **overrides}

    def test_should_edit_bundle(self):
        bundle = self.setup_bundle()

        updated_data = self.create_form_data()

        response = self.client.post(
            reverse("linkding:bundles.edit", args=[bundle.id]), updated_data
        )

        self.assertRedirects(response, reverse("linkding:bundles.index"))

        bundle.refresh_from_db()
        self.assertEqual(bundle.name, updated_data["name"])
        self.assertEqual(bundle.search, updated_data["search"])
        self.assertEqual(bundle.any_tags, updated_data["any_tags"])
        self.assertEqual(bundle.all_tags, updated_data["all_tags"])
        self.assertEqual(bundle.excluded_tags, updated_data["excluded_tags"])
        self.assertEqual(bundle.filter_unread, updated_data["filter_unread"])
        self.assertEqual(bundle.filter_shared, updated_data["filter_shared"])

    def test_should_render_edit_form_with_prefilled_fields(self):
        bundle = self.setup_bundle(
            name="Test Bundle",
            search="test search terms",
            any_tags="tag1 tag2 tag3",
            all_tags="required-tag all-tag",
            excluded_tags="excluded-tag banned-tag",
            filter_unread=BookmarkBundle.FILTER_STATE_YES,
            filter_shared=BookmarkBundle.FILTER_STATE_NO,
        )

        response = self.client.get(reverse("linkding:bundles.edit", args=[bundle.id]))

        self.assertEqual(response.status_code, 200)
        html = response.content.decode()

        self.assertInHTML(
            f"""
                <input type="text" name="name" value="{bundle.name}"
                autocomplete="off" class="form-input"
                maxlength="256" aria-invalid="false" required id="id_name">
            """,
            html,
        )

        self.assertInHTML(
            f"""
                <input type="text" name="search" value="{bundle.search}"
                autocomplete="off" class="form-input"
                maxlength="256" aria-describedby="id_search_help" id="id_search">
            """,
            html,
        )

        self.assertInHTML(
            f"""
                <ld-tag-autocomplete input-name="any_tags" input-value="{bundle.any_tags}"
                input-aria-describedby="id_any_tags_help" input-id="id_any_tags">
            """,
            html,
        )

        self.assertInHTML(
            f"""
                <ld-tag-autocomplete input-name="all_tags" input-value="{bundle.all_tags}"
                input-aria-describedby="id_all_tags_help" input-id="id_all_tags">
            """,
            html,
        )

        self.assertInHTML(
            f"""
                <ld-tag-autocomplete input-name="excluded_tags" input-value="{bundle.excluded_tags}"
                input-aria-describedby="id_excluded_tags_help" input-id="id_excluded_tags">
            """,
            html,
        )

        self.assertInHTML(
            """
                <select name="filter_unread" class="form-select"
                aria-describedby="id_filter_unread_help" id="id_filter_unread">
                    <option value="off">All</option>
                    <option value="yes" selected>Unread</option>
                    <option value="no">Read</option>
                </select>
            """,
            html,
        )

        self.assertInHTML(
            """
                <select name="filter_shared" class="form-select"
                aria-describedby="id_filter_shared_help" id="id_filter_shared">
                    <option value="off">All</option>
                    <option value="yes">Shared</option>
                    <option value="no" selected>Unshared</option>
                </select>
            """,
            html,
        )

    def test_should_return_422_with_invalid_form(self):
        bundle = self.setup_bundle(
            name="Test Bundle",
            search="test search",
            any_tags="tag1 tag2",
            all_tags="required-tag",
            excluded_tags="excluded-tag",
        )

        invalid_data = self.create_form_data({"name": ""})

        response = self.client.post(
            reverse("linkding:bundles.edit", args=[bundle.id]), invalid_data
        )

        self.assertEqual(response.status_code, 422)

    def test_should_not_allow_editing_other_users_bundles(self):
        other_user = self.setup_user(name="otheruser")
        other_users_bundle = self.setup_bundle(user=other_user)

        response = self.client.get(
            reverse("linkding:bundles.edit", args=[other_users_bundle.id])
        )
        self.assertEqual(response.status_code, 404)

        updated_data = self.create_form_data()
        response = self.client.post(
            reverse("linkding:bundles.edit", args=[other_users_bundle.id]), updated_data
        )
        self.assertEqual(response.status_code, 404)

    def test_should_show_correct_preview(self):
        bundle_tag = self.setup_tag()
        bookmark1 = self.setup_bookmark(tags=[bundle_tag])
        bookmark2 = self.setup_bookmark()
        bookmark3 = self.setup_bookmark()
        bundle = self.setup_bundle(name="Test Bundle", all_tags=bundle_tag.name)

        response = self.client.get(reverse("linkding:bundles.edit", args=[bundle.id]))
        self.assertContains(response, "Found 1 bookmarks matching this bundle")
        self.assertContains(response, bookmark1.title)
        self.assertNotContains(response, bookmark2.title)
        self.assertNotContains(response, bookmark3.title)

    def test_should_show_correct_preview_after_posting_invalid_data(self):
        initial_tag = self.setup_tag(name="initial-tag")
        updated_tag = self.setup_tag(name="updated-tag")
        bookmark1 = self.setup_bookmark(tags=[initial_tag])
        bookmark2 = self.setup_bookmark(tags=[updated_tag])
        bookmark3 = self.setup_bookmark()
        bundle = self.setup_bundle(name="Test Bundle", all_tags=initial_tag.name)

        form_data = {
            "name": "",
            "search": "",
            "any_tags": "",
            "all_tags": updated_tag.name,
            "excluded_tags": "",
        }
        response = self.client.post(
            reverse("linkding:bundles.edit", args=[bundle.id]), form_data
        )
        self.assertIn(
            "Found 1 bookmarks matching this bundle", response.content.decode()
        )
        self.assertNotIn(bookmark1.title, response.content.decode())
        self.assertIn(bookmark2.title, response.content.decode())
        self.assertNotIn(bookmark3.title, response.content.decode())


================================================
FILE: bookmarks/tests/test_bundles_index_view.py
================================================
from django.test import TestCase
from django.urls import reverse

from bookmarks.models import BookmarkBundle
from bookmarks.tests.helpers import BookmarkFactoryMixin
from bookmarks.utils import app_version


class BundleIndexViewTestCase(TestCase, BookmarkFactoryMixin):
    def setUp(self) -> None:
        user = self.get_or_create_test_user()
        self.client.force_login(user)

    def test_render_bundle_list(self):
        bundles = [
            self.setup_bundle(name="Bundle 1"),
            self.setup_bundle(name="Bundle 2"),
            self.setup_bundle(name="Bundle 3"),
        ]

        response = self.client.get(reverse("linkding:bundles.index"))

        self.assertEqual(response.status_code, 200)
        html = response.content.decode()

        for bundle in bundles:
            expected_list_item = f"""
            <tr data-bundle-id="{bundle.id}" draggable="true">
              <td>
                <div class="d-flex align-center">
                  <svg class="text-secondary mr-1" width="16" height="16">
                    <use href="/static/icons.svg?v={app_version}#drag"></use>
                  </svg>
                  <span>{bundle.name}</span>
                </div>
              </td>
              <td class="actions">
                <a class="btn btn-link" href="{reverse("linkding:bundles.edit", args=[bundle.id])}">Edit</a>
                <button data-confirm type="submit" name="remove_bundle" value="{bundle.id}" class="btn btn-link">Remove</button>
              </td>
            </tr>
            """

            self.assertInHTML(expected_list_item, html)

    def test_renders_user_owned_bundles_only(self):
        user_bundle = self.setup_bundle(name="User Bundle")

        other_user = self.setup_user(name="otheruser")
        other_user_bundle = self.setup_bundle(name="Other User Bundle", user=other_user)

        response = self.client.get(reverse("linkding:bundles.index"))

        self.assertEqual(response.status_code, 200)
        html = response.content.decode()

        self.assertInHTML(f"<span>{user_bundle.name}</span>", html)
        self.assertNotIn(other_user_bundle.name, html)

    def test_empty_state(self):
        response = self.client.get(reverse("linkding:bundles.index"))

        self.assertEqual(response.status_code, 200)
        html = response.content.decode()

        self.assertInHTML('<p class="empty-title h5">You have no bundles yet</p>', html)
        self.assertInHTML(
            '<p class="empty-subtitle">Create your first bundle to get started</p>',
            html,
        )

    def test_add_new_button(self):
        response = self.client.get(reverse("linkding:bundles.index"))

        self.assertEqual(response.status_code, 200)
        html = response.content.decode()

        self.assertInHTML(
            f'<a href="{reverse("linkding:bundles.new")}" class="btn">Add bundle</a>',
            html,
        )

    def test_remove_bundle(self):
        bundle = self.setup_bundle(name="Test Bundle")

        response = self.client.post(
            reverse("linkding:bundles.action"),
            {"remove_bundle": str(bundle.id)},
        )

        self.assertEqual(response.status_code, 302)
        self.assertRedirects(response, reverse("linkding:bundles.index"))

        self.assertFalse(BookmarkBundle.objects.filter(id=bundle.id).exists())

    def test_remove_bundle_updates_order(self):
        bundle1 = self.setup_bundle(name="Bundle 1", order=0)
        bundle2 = self.setup_bundle(name="Bundle 2", order=1)
        bundle3 = self.setup_bundle(name="Bundle 3", order=2)

        self.client.post(
            reverse("linkding:bundles.action"),
            {"remove_bundle": str(bundle2.id)},
        )

        self.assertBundleOrder([bundle1, bundle3])

    def test_remove_other_user_bundle(self):
        other_user = self.setup_user(name="otheruser")
        other_user_bundle = self.setup_bundle(name="Other User Bundle", user=other_user)

        response = self.client.post(
            reverse("linkding:bundles.action"),
            {"remove_bundle": str(other_user_bundle.id)},
        )

        self.assertEqual(response.status_code, 404)
        self.assertTrue(BookmarkBundle.objects.filter(id=other_user_bundle.id).exists())

    def assertBundleOrder(self, expected_bundles, user=None):
        if user is None:
            user = self.user
        actual_bundles = BookmarkBundle.objects.filter(owner=user).order_by("order")
        self.assertEqual(len(actual_bundles), len(expected_bundles))
        for i, bundle in enumerate(expected_bundles):
            self.assertEqual(actual_bundles[i].id, bundle.id)
            self.assertEqual(actual_bundles[i].order, i)

    def move_bundle(self, bundle: BookmarkBundle, position: int):
        return self.client.post(
            reverse("linkding:bundles.action"),
            {"move_bundle": str(bundle.id), "move_position": position},
        )

    def test_move_bundle(self):
        bundle1 = self.setup_bundle(name="Bundle 1", order=0)
        bundle2 = self.setup_bundle(name="Bundle 2", order=1)
        bundle3 = self.setup_bundle(name="Bundle 3", order=2)

        self.move_bundle(bundle1, 1)
        self.assertBundleOrder([bundle2, bundle1, bundle3])

        self.move_bundle(bundle1, 0)
        self.assertBundleOrder([bundle1, bundle2, bundle3])

        self.move_bundle(bundle1, 2)
        self.assertBundleOrder([bundle2, bundle3, bundle1])

        self.move_bundle(bundle1, 2)
        self.assertBundleOrder([bundle2, bundle3, bundle1])

    def test_move_bundle_response(self):
        bundle1 = self.setup_bundle(name="Bundle 1", order=0)
        self.setup_bundle(name="Bundle 2", order=1)

        response = self.move_bundle(bundle1, 1)

        self.assertEqual(response.status_code, 302)
        self.assertRedirects(response, reverse("linkding:bundles.index"))

    def test_can_only_move_user_owned_bundles(self):
        other_user = self.setup_user()
        other_user_bundle1 = self.setup_bundle(user=other_user)
        self.setup_bundle(user=other_user)

        response = self.move_bundle(other_user_bundle1, 1)
        self.assertEqual(response.status_code, 404)

    def test_move_bundle_only_affects_own_bundles(self):
        user_bundle1 = self.setup_bundle(name="User Bundle 1", order=0)
        user_bundle2 = self.setup_bundle(name="User Bundle 2", order=1)

        other_user = self.setup_user(name="otheruser")
        other_user_bundle = self.setup_bundle(
            name="Other User Bundle", user=other_user, order=0
        )

        # Move user bundle
        self.move_bundle(user_bundle1, 1)
        self.assertBundleOrder([user_bundle2, user_bundle1], user=self.user)

        # Check that other user's bundle is unaffected
        self.assertBundleOrder([other_user_bundle], user=other_user)

    def test_remove_non_existing_bundle(self):
        non_existent_id = 99999

        response = self.client.post(
            reverse("linkding:bundles.action"),
            {"remove_bundle": str(non_existent_id)},
        )

        self.assertEqual(response.status_code, 404)

    def test_post_without_action(self):
        bundle = self.setup_bundle(name="Test Bundle")

        response = self.client.post(reverse("linkding:bundles.action"), {})

        self.assertEqual(response.status_code, 302)
        self.assertRedirects(response, reverse("linkding:bundles.index"))

        self.assertTrue(BookmarkBundle.objects.filter(id=bundle.id).exists())


================================================
FILE: bookmarks/tests/test_bundles_new_view.py
================================================
from urllib.parse import urlencode

from django.test import TestCase
from django.urls import reverse

from bookmarks.models import BookmarkBundle
from bookmarks.tests.helpers import BookmarkFactoryMixin, HtmlTestMixin


class BundleNewViewTestCase(TestCase, BookmarkFactoryMixin, HtmlTestMixin):
    def setUp(self) -> None:
        user = self.get_or_create_test_user()
        self.client.force_login(user)

    def create_form_data(self, overrides=None):
        if overrides is None:
            overrides = {}
        form_data = {
            "name": "Test Bundle",
            "search": "test search",
            "any_tags": "tag1 tag2",
            "all_tags": "required-tag",
            "excluded_tags": "excluded-tag",
            "filter_unread": BookmarkBundle.FILTER_STATE_YES,
            "filter_shared": BookmarkBundle.FILTER_STATE_NO,
        }
        return {**form_data, **overrides}

    def test_should_create_new_bundle(self):
        form_data = self.create_form_data()

        response = self.client.post(reverse("linkding:bundles.new"), form_data)

        self.assertEqual(BookmarkBundle.objects.count(), 1)

        bundle = BookmarkBundle.objects.first()
        self.assertEqual(bundle.owner, self.user)
        self.assertEqual(bundle.name, form_data["name"])
        self.assertEqual(bundle.search, form_data["search"])
        self.assertEqual(bundle.any_tags, form_data["any_tags"])
        self.assertEqual(bundle.all_tags, form_data["all_tags"])
        self.assertEqual(bundle.excluded_tags, form_data["excluded_tags"])
        self.assertEqual(bundle.filter_unread, form_data["filter_unread"])
        self.assertEqual(bundle.filter_shared, form_data["filter_shared"])

        self.assertRedirects(response, reverse("linkding:bundles.index"))

    def test_should_increment_order_for_subsequent_bundles(self):
        # Create first bundle
        form_data_1 = self.create_form_data({"name": "Bundle 1"})
        self.client.post(reverse("linkding:bundles.new"), form_data_1)
        bundle1 = BookmarkBundle.objects.get(name="Bundle 1")
        self.assertEqual(bundle1.order, 0)

        # Create second bundle
        form_data_2 = self.create_form_data({"name": "Bundle 2"})
        self.client.post(reverse("linkding:bundles.new"), form_data_2)
        bundle2 = BookmarkBundle.objects.get(name="Bundle 2")
        self.assertEqual(bundle2.order, 1)

        # Create another bundle with a higher order
        self.setup_bundle(order=5)

        # Create third bundle
        form_data_3 = self.create_form_data({"name": "Bundle 3"})
        self.client.post(reverse("linkding:bundles.new"), form_data_3)
        bundle3 = BookmarkBundle.objects.get(name="Bundle 3")
        self.assertEqual(bundle3.order, 6)

    def test_incrementing_order_ignores_other_user_bookmark(self):
        other_user = self.setup_user()
        self.setup_bundle(user=other_user, order=10)

        form_data = self.create_form_data({"name": "Bundle 1"})
        self.client.post(reverse("linkding:bundles.new"), form_data)
        bundle1 = BookmarkBundle.objects.get(name="Bundle 1")
        self.assertEqual(bundle1.order, 0)

    def test_should_return_422_with_invalid_form(self):
        form_data = self.create_form_data({"name": ""})
        response = self.client.post(reverse("linkding:bundles.new"), form_data)
        self.assertEqual(response.status_code, 422)

    def test_should_prefill_form_from_search_query_parameters(self):
        query = "machine learning #python #ai"
        url = reverse("linkding:bundles.new") + "?" + urlencode({"q": query})
        response = self.client.get(url)

        soup = self.make_soup(response.content.decode())
        search_field = soup.select_one('input[name="search"]')
        all_tags_field = soup.select_one('ld-tag-autocomplete[input-name="all_tags"]')

        self.assertEqual(search_field.get("value"), "machine learning")
        self.assertEqual(all_tags_field.get("input-value"), "python ai")

    def test_should_ignore_special_search_commands(self):
        query = "python tutorial !untagged !unread"
        url = reverse("linkding:bundles.new") + "?" + urlencode({"q": query})
        response = self.client.get(url)

        soup = self.make_soup(response.content.decode())
        search_field = soup.select_one('input[name="search"]')
        all_tags_field = soup.select_one('ld-tag-autocomplete[input-name="all_tags"]')

        self.assertEqual(search_field.get("value"), "python tutorial")
        self.assertEqual(all_tags_field.get("input-value"), "")

    def test_should_not_prefill_when_no_query_parameter(self):
        response = self.client.get(reverse("linkding:bundles.new"))

        soup = self.make_soup(response.content.decode())
        search_field = soup.select_one('input[name="search"]')
        all_tags_field = soup.select_one('ld-tag-autocomplete[input-name="all_tags"]')

        self.assertIsNone(search_field.get("value"))
        self.assertEqual(all_tags_field.get("input-value"), "")

    def test_should_not_prefill_when_editing_existing_bundle(self):
        bundle = self.setup_bundle(
            name="Existing Bundle", search="Tutorial", all_tags="java spring"
        )

        query = "machine learning #python #ai"
        url = (
            reverse("linkding:bundles.edit", args=[bundle.id])
            + "?"
            + urlencode({"q": query})
        )
        response = self.client.get(url)

        soup = self.make_soup(response.content.decode())
        search_field = soup.select_one('input[name="search"]')
        all_tags_field = soup.select_one('ld-tag-autocomplete[input-name="all_tags"]')

        self.assertEqual(search_field.get("value"), "Tutorial")
        self.assertEqual(all_tags_field.get("input-value"), "java spring")

    def test_should_show_correct_preview_with_prefilled_values(self):
        bundle_tag = self.setup_tag()
        bookmark1 = self.setup_bookmark(tags=[bundle_tag])
        bookmark2 = self.setup_bookmark()
        bookmark3 = self.setup_bookmark()

        query = "#" + bundle_tag.name
        url = reverse("linkding:bundles.new") + "?" + urlencode({"q": query})
        response = self.client.get(url)

        self.assertContains(response, "Found 1 bookmarks matching this bundle")
        self.assertContains(response, bookmark1.title)
        self.assertNotContains(response, bookmark2.title)
        self.assertNotContains(response, bookmark3.title)


================================================
FILE: bookmarks/tests/test_bundles_preview_view.py
================================================
from django.test import TestCase
from django.urls import reverse

from bookmarks.models import BookmarkBundle
from bookmarks.tests.helpers import BookmarkFactoryMixin, HtmlTestMixin


class BundlePreviewViewTestCase(TestCase, BookmarkFactoryMixin, HtmlTestMixin):
    def setUp(self) -> None:
        user = self.get_or_create_test_user()
        self.client.force_login(user)

    def test_preview_empty_bundle(self):
        bookmark1 = self.setup_bookmark(title="Test Bookmark 1")
        bookmark2 = self.setup_bookmark(title="Test Bookmark 2")

        response = self.client.get(reverse("linkding:bundles.preview"))

        self.assertEqual(response.status_code, 200)
        self.assertContains(response, "Found 2 bookmarks matching this bundle")
        self.assertContains(response, bookmark1.title)
        self.assertContains(response, bookmark2.title)
        self.assertNotContains(response, "No bookmarks match the current bundle")

    def test_preview_with_search_terms(self):
        bookmark1 = self.setup_bookmark(title="Python Programming")
        bookmark2 = self.setup_bookmark(title="JavaScript Tutorial")
        bookmark3 = self.setup_bookmark(title="Django Framework")

        response = self.client.get(
            reverse("linkding:bundles.preview"), {"search": "python"}
        )

        self.assertEqual(response.status_code, 200)
        self.assertContains(response, "Found 1 bookmarks matching this bundle")
        self.assertContains(response, bookmark1.title)
        self.assertNotContains(response, bookmark2.title)
        self.assertNotContains(response, bookmark3.title)

    def test_preview_no_matching_bookmarks(self):
        bookmark = self.setup_bookmark(title="Python Guide")

        response = self.client.get(
            reverse("linkding:bundles.preview"), {"search": "nonexistent"}
        )

        self.assertEqual(response.status_code, 200)
        self.assertContains(response, "No bookmarks match the current bundle")
        self.assertNotContains(response, bookmark.title)

    def test_preview_renders_bookmark(self):
        tag = self.setup_tag(name="test-tag")
        bookmark = self.setup_bookmark(
            title="Test Bookmark",
            description="Test description",
            url="https://example.com/test",
            tags=[tag],
        )

        response = self.client.get(reverse("linkding:bundles.preview"))

        self.assertEqual(response.status_code, 200)
        self.assertContains(response, bookmark.title)
        self.assertContains(response, bookmark.description)
        self.assertContains(response, bookmark.url)
        self.assertContains(response, "#test-tag")

    def test_preview_renders_bookmark_in_preview_mode(self):
        tag = self.setup_tag(name="test-tag")
        self.setup_bookmark(
            title="Test Bookmark",
            description="Test description",
            url="https://example.com/test",
            tags=[tag],
        )

        response = self.client.get(reverse("linkding:bundles.preview"))
        soup = self.make_soup(response.content.decode())

        list_item = soup.select_one("ul.bookmark-list > li")
        actions = list_item.select(".actions > *")
        self.assertEqual(len(actions), 1)

    def test_preview_ignores_archived_bookmarks(self):
        active_bookmark = self.setup_bookmark(title="Active Bookmark")
        archived_bookmark = self.setup_bookmark(
            title="Archived Bookmark", is_archived=True
        )

        response = self.client.get(reverse("linkding:bundles.preview"))

        self.assertEqual(response.status_code, 200)
        self.assertContains(response, "Found 1 bookmarks matching this bundle")
        self.assertContains(response, active_bookmark.title)
        self.assertNotContains(response, archived_bookmark.title)

    def test_preview_with_filter_unread(self):
        unread_bookmark = self.setup_bookmark(title="Unread Bookmark", unread=True)
        read_bookmark = self.setup_bookmark(title="Read Bookmark", unread=False)

        # Filter unread
        response = self.client.get(
            reverse("linkding:bundles.preview"),
            {"filter_unread": BookmarkBundle.FILTER_STATE_YES},
        )
        self.assertContains(response, "Found 1 bookmarks matching this bundle")
        self.assertContains(response, unread_bookmark.title)
        self.assertNotContains(response, read_bookmark.title)

        # Filter read
        response = self.client.get(
            reverse("linkding:bundles.preview"),
            {"filter_unread": BookmarkBundle.FILTER_STATE_NO},
        )
        self.assertContains(response, "Found 1 bookmarks matching this bundle")
        self.assertNotContains(response, unread_bookmark.title)
        self.assertContains(response, read_bookmark.title)

        # Filter off
        response = self.client.get(
            reverse("linkding:bundles.preview"),
            {"filter_unread": BookmarkBundle.FILTER_STATE_OFF},
        )
        self.assertContains(response, "Found 2 bookmarks matching this bundle")
        self.assertContains(response, unread_bookmark.title)
        self.assertContains(response, read_bookmark.title)

    def test_preview_with_filter_shared(self):
        shared_bookmark = self.setup_bookmark(title="Shared Bookmark", shared=True)
        unshared_bookmark = self.setup_bookmark(title="Unshared Bookmark", shared=False)

        # Filter shared
        response = self.client.get(
            reverse("linkding:bundles.preview"),
            {"filter_shared": BookmarkBundle.FILTER_STATE_YES},
        )
        self.assertContains(response, "Found 1 bookmarks matching this bundle")
        self.assertContains(response, shared_bookmark.title)
        self.assertNotContains(response, unshared_bookmark.title)

        # Filter unshared
        response = self.client.get(
            reverse("linkding:bundles.preview"),
            {"filter_shared": BookmarkBundle.FILTER_STATE_NO},
        )
        self.assertContains(response, "Found 1 bookmarks matching this bundle")
        self.assertNotContains(response, shared_bookmark.title)
        self.assertContains(response, unshared_bookmark.title)

        # Filter off
        response = self.client.get(
            reverse("linkding:bundles.preview"),
            {"filter_shared": BookmarkBundle.FILTER_STATE_OFF},
        )
        self.assertContains(response, "Found 2 bookmarks matching this bundle")
        self.assertContains(response, shared_bookmark.title)
        self.assertContains(response, unshared_bookmark.title)

    def test_preview_requires_authentication(self):
        self.client.logout()

        response = self.client.get(reverse("linkding:bundles.preview"), follow=True)

        self.assertRedirects(
            response, f"/login/?next={reverse('linkding:bundles.preview')}"
        )

    def test_preview_only_shows_user_bookmarks(self):
        other_user = self.setup_user()
        own_bookmark = self.setup_bookmark(title="Own Bookmark")
        other_bookmark = self.setup_bookmark(title="Other Bookmark", user=other_user)

        response = self.client.get(reverse("linkding:bundles.preview"))

        self.assertEqual(response.status_code, 200)
        self.assertContains(response, "Found 1 bookmarks matching this bundle")
        self.assertContains(response, own_bookmark.title)
        self.assertNotContains(response, other_bookmark.title)


================================================
FILE: bookmarks/tests/test_context_path.py
================================================
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.urls_module = importlib.import_module("bookmarks.urls")

    @override_settings(LD_CONTEXT_PATH=None)
    def tearDown(self):
        importlib.reload(self.urls_module)

    @override_settings(LD_CONTEXT_PATH="linkding/")
    def test_route_with_context_path(self):
        module = importlib.reload(self.urls_module)
        # pass mock config instead of actual module to prevent caching the
        # url config in django.urls.reverse
        urlconf = MockUrlConf(module)
        test_cases = [
            ("linkding:bookmarks.index", "/linkding/bookmarks"),
            ("linkding: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.urls_module)
        # pass mock config instead of actual module to prevent caching the
        # url config in django.urls.reverse
        urlconf = MockUrlConf(module)
        test_cases = [
            ("linkding:bookmarks.index", "/bookmarks"),
            ("linkding: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)


================================================
FILE: bookmarks/tests/test_create_initial_superuser_command.py
================================================
import os
from unittest import mock

from django.test import TestCase

from bookmarks.management.commands.create_initial_superuser import Command
from bookmarks.models import User


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())


================================================
FILE: bookmarks/tests/test_custom_css_view.py
================================================
from django.test import TestCase
from django.urls import reverse

from bookmarks.tests.helpers import BookmarkFactoryMixin


class CustomCssViewTestCase(TestCase, BookmarkFactoryMixin):
    def setUp(self) -> None:
        user = self.get_or_create_test_user()
        self.client.force_login(user)

    def test_with_empty_css(self):
        response = self.client.get(reverse("linkding:custom_css"))
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response["Content-Type"], "text/css")
        self.assertEqual(response.headers["Cache-Control"], "public, max-age=2592000")
        self.assertEqual(response.content.decode(), "")

    def test_with_custom_css(self):
        css = "body { background-color: red; }"
        self.user.profile.custom_css = css
        self.user.profile.save()

        response = self.client.get(reverse("linkding:custom_css"))
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response["Content-Type"], "text/css")
        self.assertEqual(response.headers["Cache-Control"], "public, max-age=2592000")
        self.assertEqual(response.content.decode(), css)


================================================
FILE: bookmarks/tests/test_exporter.py
================================================
from datetime import UTC, datetime

from django.test import TestCase

from bookmarks.services import exporter
from bookmarks.tests.helpers import BookmarkFactoryMixin


class ExporterTestCase(TestCase, BookmarkFactoryMixin):
    def test_export_bookmarks(self):
        bookmarks = [
            self.setup_bookmark(
                url="https://example.com/1",
                title="Title 1",
                added=datetime.fromtimestamp(1, UTC),
                modified=datetime.fromtimestamp(11, UTC),
                description="Example description",
            ),
            self.setup_bookmark(
                url="https://example.com/2",
                title="Title 2",
                added=datetime.fromtimestamp(2, UTC),
                modified=datetime.fromtimestamp(22, UTC),
                tags=[
                    self.setup_tag(name="tag1"),
                    self.setup_tag(name="tag2"),
                    self.setup_tag(name="tag3"),
                ],
            ),
            self.setup_bookmark(
                url="https://example.com/3",
                title="Title 3",
                added=datetime.fromtimestamp(3, UTC),
                modified=datetime.fromtimestamp(33, UTC),
                unread=True,
            ),
            self.setup_bookmark(
                url="https://example.com/4",
                title="Title 4",
                added=datetime.fromtimestamp(4, UTC),
                modified=datetime.fromtimestamp(44, UTC),
                shared=True,
            ),
            self.setup_bookmark(
                url="https://example.com/5",
                title="Title 5",
                added=datetime.fromtimestamp(5, UTC),
                modified=datetime.fromtimestamp(55, UTC),
                shared=True,
                description="Example description",
                notes="Example notes",
            ),
            self.setup_bookmark(
                url="https://example.com/6",
                title="Title 6",
                added=datetime.fromtimestamp(6, UTC),
                modified=datetime.fromtimestamp(66, UTC),
                shared=True,
                notes="Example notes",
            ),
            self.setup_bookmark(
                url="https://example.com/7",
                title="Title 7",
                added=datetime.fromtimestamp(7, UTC),
                modified=datetime.fromtimestamp(77, UTC),
                is_archived=True,
            ),
            self.setup_bookmark(
                url="https://example.com/8",
                title="Title 8",
                added=datetime.fromtimestamp(8, UTC),
                modified=datetime.fromtimestamp(88, UTC),
                tags=[self.setup_tag(name="tag4"), self.setup_tag(name="tag5")],
                is_archived=True,
            ),
        ]
        html = exporter.export_netscape_html(bookmarks)

        lines = [
            '<DT><A HREF="https://example.com/1" ADD_DATE="1" LAST_MODIFIED="11" PRIVATE="1" TOREAD="0" TAGS="">Title 1</A>',
            "<DD>Example description",
            '<DT><A HREF="https://example.com/2" ADD_DATE="2" LAST_MODIFIED="22" PRIVATE="1" TOREAD="0" TAGS="tag1,tag2,tag3">Title 2</A>',
            '<DT><A HREF="https://example.com/3" ADD_DATE="3" LAST_MODIFIED="33" PRIVATE="1" TOREAD="1" TAGS="">Title 3</A>',
            '<DT><A HREF="https://example.com/4" ADD_DATE="4" LAST_MODIFIED="44" PRIVATE="0" TOREAD="0" TAGS="">Title 4</A>',
            '<DT><A HREF="https://example.com/5" ADD_DATE="5" LAST_MODIFIED="55" PRIVATE="0" TOREAD="0" TAGS="">Title 5</A>',
            "<DD>Example description[linkding-notes]Example notes[/linkding-notes]",
            '<DT><A HREF="https://example.com/6" ADD_DATE="6" LAST_MODIFIED="66" PRIVATE="0" TOREAD="0" TAGS="">Title 6</A>',
            "<DD>[linkding-notes]Example notes[/linkding-notes]",
            '<DT><A HREF="https://example.com/7" ADD_DATE="7" LAST_MODIFIED="77" PRIVATE="1" TOREAD="0" TAGS="linkding:bookmarks.archived">Title 7</A>',
            '<DT><A HREF="https://example.com/8" ADD_DATE="8" LAST_MODIFIED="88" PRIVATE="1" TOREAD="0" TAGS="tag4,tag5,linkding:bookmarks.archived">Title 8</A>',
        ]
        self.assertIn("\n\r".join(lines), html)

    def test_escape_html(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.",
            notes="Interesting notes about the <style> HTML element.",
        )
        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,
        )
        self.assertIn("Interesting notes about the &lt;style&gt; HTML element.", html)

    def test_handle_empty_values(self):
        bookmark = self.setup_bookmark()
        bookmark.title = ""
        bookmark.description = ""
        bookmark.save()
        exporter.export_netscape_html([bookmark])


================================================
FILE: bookmarks/tests/test_exporter_performance.py
================================================
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 _i 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("linkding:settings.export"), follow=True)

        number_of_queries = context.final_queries

        self.assertLess(number_of_queries, num_initial_bookmarks)


================================================
FILE: bookmarks/tests/test_favicon_loader.py
================================================
import io
import os.path
import tempfile
import time
from pathlib import Path
from unittest import mock

from django.conf import settings
from django.test import TestCase, override_settings

from bookmarks.services import favicon_loader

mock_icon_data = b"mock_icon"


class MockStreamingResponse:
    def __init__(self, data=mock_icon_data, content_type="image/png"):
        self.chunks = [data]
        self.headers = {"Content-Type": content_type}

    def iter_content(self, **kwargs):
        return self.chunks

    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        pass


class FaviconLoaderTestCase(TestCase):
    def setUp(self) -> None:
        self.temp_favicon_folder = tempfile.TemporaryDirectory()
        self.favicon_folder_override = self.settings(
            LD_FAVICON_FOLDER=self.temp_favicon_folder.name
        )
        self.favicon_folder_override.enable()

    def tearDown(self) -> None:
        self.temp_favicon_folder.cleanup()
        self.favicon_folder_override.disable()

    def create_mock_response(self, icon_data=mock_icon_data, content_type="image/png"):
        mock_response = mock.Mock()
        mock_response.raw = io.BytesIO(icon_data)
        return MockStreamingResponse(icon_data, content_type)

    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_file = favicon_loader.load_favicon("https://example.com")
            mock_get.assert_called()
            self.assertEqual(favicon_file, "https_example_com.png")

            mock_get.reset_mock()
            updated_favicon_file = favicon_loader.load_favicon("https://example.com")
            mock_get.assert_not_called()
            self.assertEqual(favicon_file, updated_favicon_file)

    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")
            )

    @override_settings(LD_FAVICON_PROVIDER="https://custom.icons.com/?url={url}")
    def test_custom_provider_with_url_param(self):
        with mock.patch("requests.get") as mock_get:
            mock_get.return_value = self.create_mock_response()

            favicon_loader.load_favicon("https://example.com/foo?bar=baz")
            mock_get.assert_called_with(
                "https://custom.icons.com/?url=https://example.com", stream=True
            )

    @override_settings(LD_FAVICON_PROVIDER="https://custom.icons.com/?url={domain}")
    def test_custom_provider_with_domain_param(self):
        with mock.patch("requests.get") as mock_get:
            mock_get.return_value = self.create_mock_response()

            favicon_loader.load_favicon("https://example.com/foo?bar=baz")
            mock_get.assert_called_with(
                "https://custom.icons.com/?url=example.com", stream=True
            )

    def test_guess_file_extension(self):
        with mock.patch("requests.get") as mock_get:
            mock_get.return_value = self.create_mock_response(content_type="image/png")
            favicon_loader.load_favicon("https://example.com")

            self.assertTrue(self.icon_exists("https_example_com.png"))

        self.clear_favicon_folder()

        with mock.patch("requests.get") as mock_get:
            mock_get.return_value = self.create_mock_response(
                content_type="image/x-icon"
            )
            favicon_loader.load_favicon("https://example.com")

            self.assertTrue(self.icon_exists("https_example_com.ico"))


================================================
FILE: bookmarks/tests/test_feeds.py
================================================
import datetime
import email
import unittest
import urllib.parse

from django.conf import settings
from django.test import TestCase
from django.urls import reverse

from bookmarks.feeds import sanitize
from bookmarks.models import FeedToken, User
from bookmarks.tests.helpers import BookmarkFactoryMixin


def rfc2822_date(date):
    if not isinstance(date, datetime.datetime):
        date = datetime.datetime.combine(date, datetime.time())
    return email.utils.format_datetime(date)


class FeedsTestCase(TestCase, BookmarkFactoryMixin):
    def setUp(self) -> None:
        user = self.get_or_create_test_user()
        self.client.force_login(user)
        self.token = FeedToken.objects.get_or_create(user=user)[0]

    def assertFeedItems(self, response, bookmarks):
        self.assertContains(response, "<item>", count=len(bookmarks))

        for bookmark in bookmarks:
            categories = []
            for tag in bookmark.tag_names:
                categories.append(f"<category>{tag}</category>")

            if bookmark.resolved_description:
                expected_description = (
                    f"<description>{bookmark.resolved_description}</description>"
                )
            else:
                expected_description = "<description/>"

            expected_item = (
                "<item>"
                f"<title>{bookmark.resolved_title}</title>"
                f"<link>{bookmark.url}</link>"
                f"{expected_description}"
                f"<pubDate>{rfc2822_date(bookmark.date_added)}</pubDate>"
                f"<guid>{bookmark.url}</guid>"
                f"{''.join(categories)}"
                "</item>"
            )
            self.assertContains(response, expected_item, count=1)

    def test_all_returns_404_for_unknown_feed_token(self):
        response = self.client.get(reverse("linkding:feeds.all", args=["foo"]))

        self.assertEqual(response.status_code, 404)

    def test_all_metadata(self):
        feed_url = reverse("linkding:feeds.all", args=[self.token.key])
        response = self.client.get(feed_url)
        self.assertEqual(response.status_code, 200)

        self.assertContains(response, "<title>All bookmarks</title>")
        self.assertContains(response, "<description>All bookmarks</description>")
        self.assertContains(response, f"<link>http://testserver{feed_url}</link>")
        self.assertContains(
            response, f'<atom:link href="http://testserver{feed_url}" rel="self"/>'
        )

    def test_all_returns_all_unarchived_bookmarks(self):
        bookmarks = [
            self.setup_bookmark(description="test description"),
            self.setup_bookmark(description=""),
            self.setup_bookmark(unread=True, description="test description"),
        ]
        self.setup_bookmark(is_archived=True)
        self.setup_bookmark(is_archived=True)
        self.setup_bookmark(is_archived=True)

        response = self.client.get(reverse("linkding:feeds.all", args=[self.token.key]))
        self.assertEqual(response.status_code, 200)
        self.assertFeedItems(response, bookmarks)

    def test_all_returns_only_user_owned_bookmarks(self):
        other_user = User.objects.create_user(
            "otheruser", "otheruser@example.com", "password123"
        )
        self.setup_bookmark(unread=True, user=other_user)
        self.setup_bookmark(unread=True, user=other_user)
        self.setup_bookmark(unread=True, user=other_user)

        response = self.client.get(reverse("linkding:feeds.all", args=[self.token.key]))
        self.assertEqual(response.status_code, 200)

        self.assertContains(response, "<item>", count=0)

    def test_unread_returns_404_for_unknown_feed_token(self):
        response = self.client.get(reverse("linkding:feeds.unread", args=["foo"]))

        self.assertEqual(response.status_code, 404)

    def test_unread_metadata(self):
        feed_url = reverse("linkding:feeds.unread", args=[self.token.key])
        response = self.client.get(feed_url)
        self.assertEqual(response.status_code, 200)

        self.assertContains(response, "<title>Unread bookmarks</title>")
        self.assertContains(response, "<description>All unread bookmarks</description>")
        self.assertContains(response, f"<link>http://testserver{feed_url}</link>")
        self.assertContains(
            response, f'<atom:link href="http://testserver{feed_url}" rel="self"/>'
        )

    def test_unread_returns_unread_and_unarchived_bookmarks(self):
        self.setup_bookmark(unread=False)
        self.setup_bookmark(unread=False)
        self.setup_bookmark(unread=False)
        self.setup_bookmark(unread=True, is_archived=True)
        self.setup_bookmark(unread=True, is_archived=True)
        self.setup_bookmark(unread=False, is_archived=True)

        unread_bookmarks = [
            self.setup_bookmark(unread=True, description="test description"),
            self.setup_bookmark(unread=True, description=""),
            self.setup_bookmark(unread=True, description="test description"),
        ]

        response = self.client.get(
            reverse("linkding:feeds.unread", args=[self.token.key])
        )
        self.assertEqual(response.status_code, 200)
        self.assertFeedItems(response, unread_bookmarks)

    def test_unread_returns_only_user_owned_bookmarks(self):
        other_user = User.objects.create_user(
            "otheruser", "otheruser@example.com", "password123"
        )
        self.setup_bookmark(unread=True, user=other_user)
        self.setup_bookmark(unread=True, user=other_user)
        self.setup_bookmark(unread=True, user=other_user)

        response = self.client.get(
            reverse("linkding:feeds.unread", args=[self.token.key])
        )
        self.assertEqual(response.status_code, 200)

        self.assertContains(response, "<item>", count=0)

    def test_shared_returns_404_for_unknown_feed_token(self):
        response = self.client.get(reverse("linkding:feeds.shared", args=["foo"]))

        self.assertEqual(response.status_code, 404)

    def test_shared_metadata(self):
        feed_url = reverse("linkding:feeds.shared", args=[self.token.key])
        response = self.client.get(feed_url)
        self.assertEqual(response.status_code, 200)

        self.assertContains(response, "<title>Shared bookmarks</title>")
        self.assertContains(response, "<description>All shared bookmarks</description>")
        self.assertContains(response, f"<link>http://testserver{feed_url}</link>")
        self.assertContains(
            response, f'<atom:link href="http://testserver{feed_url}" rel="self"/>'
        )

    def test_shared_returns_shared_bookmarks_only(self):
        user1 = self.setup_user(enable_sharing=True)
        user2 = self.setup_user(enable_sharing=False)

        self.setup_bookmark()
        self.setup_bookmark(shared=False, user=user1)
        self.setup_bookmark(shared=True, user=user2)

        shared_bookmarks = [
            self.setup_bookmark(shared=True, user=user1, description="test"),
            self.setup_bookmark(shared=True, user=user1, description="test"),
            self.setup_bookmark(shared=True, user=user1, description="test"),
        ]

        response = self.client.get(
            reverse("linkding:feeds.shared", args=[self.token.key])
        )
        self.assertEqual(response.status_code, 200)
        self.assertFeedItems(response, shared_bookmarks)

    def test_public_shared_does_not_require_auth(self):
        response = self.client.get(reverse("linkding:feeds.public_shared"))

        self.assertEqual(response.status_code, 200)

    def test_public_shared_metadata(self):
        feed_url = reverse("linkding:feeds.public_shared")
        response = self.client.get(feed_url)
        self.assertEqual(response.status_code, 200)

        self.assertContains(response, "<title>Public shared bookmarks</title>")
        self.assertContains(
            response, "<description>All public shared bookmarks</description>"
        )
        self.assertContains(response, f"<link>http://testserver{feed_url}</link>")
        self.assertContains(
            response, f'<atom:link href="http://testserver{feed_url}" rel="self"/>'
        )

    def test_public_shared_returns_publicly_shared_bookmarks_only(self):
        user1 = self.setup_user(enable_sharing=True, enable_public_sharing=True)
        user2 = self.setup_user(enable_sharing=True)
        user3 = self.setup_user(enable_sharing=False)

        self.setup_bookmark()
        self.setup_bookmark(shared=False, user=user1)
        self.setup_bookmark(shared=False, user=user2)
        self.setup_bookmark(shared=True, user=user2)
        self.setup_bookmark(shared=True, user=user3)

        public_shared_bookmarks = [
            self.setup_bookmark(shared=True, user=user1, description="test"),
            self.setup_bookmark(shared=True, user=user1, description="test"),
            self.setup_bookmark(shared=True, user=user1, description="test"),
        ]

        response = self.client.get(reverse("linkding:feeds.public_shared"))
        self.assertEqual(response.status_code, 200)
        self.assertFeedItems(response, public_shared_bookmarks)

    def test_with_query(self):
        tag1 = self.setup_tag()
        bookmark1 = self.setup_bookmark()
        bookmark2 = self.setup_bookmark(tags=[tag1])
        bookmark3 = self.setup_bookmark(tags=[tag1])

        self.setup_bookmark()
        self.setup_bookmark()
        self.setup_bookmark()

        feed_url = reverse("linkding:feeds.all", args=[self.token.key])

        url = feed_url + f"?q={bookmark1.title}"
        response = self.client.get(url)
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, "<item>", count=1)
        self.assertContains(response, f"<guid>{bookmark1.url}</guid>", count=1)

        url = feed_url + "?q=" + urllib.parse.quote("#" + tag1.name)
        response = self.client.get(url)
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, "<item>", count=2)
        self.assertContains(response, f"<guid>{bookmark2.url}</guid>", count=1)
        self.assertContains(response, f"<guid>{bookmark3.url}</guid>", count=1)

        url = feed_url + "?q=" + urllib.parse.quote(f"#{tag1.name} {bookmark2.title}")
        response = self.client.get(url)
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, "<item>", count=1)
        self.assertContains(response, f"<guid>{bookmark2.url}</guid>", count=1)

    def test_unread_parameter(self):
        self.setup_bookmark(unread=True)
        self.setup_bookmark(unread=True)
        self.setup_bookmark(unread=False)
        self.setup_bookmark(unread=False)
        self.setup_bookmark(unread=False)
        self.setup_bookmark(unread=False)

        # without unread parameter
        response = self.client.get(reverse("linkding:feeds.all", args=[self.token.key]))
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, "<item>", count=6)

        # with unread=yes
        response = self.client.get(
            reverse("linkding:feeds.all", args=[self.token.key]) + "?unread=yes"
        )
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, "<item>", count=2)

        # with unread=no
        response = self.client.get(
            reverse("linkding:feeds.all", args=[self.token.key]) + "?unread=no"
        )
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, "<item>", count=4)

    def test_shared_parameter(self):
        self.setup_bookmark(shared=True)
        self.setup_bookmark(shared=True)
        self.setup_bookmark(shared=False)
        self.setup_bookmark(shared=False)
        self.setup_bookmark(shared=False)
        self.setup_bookmark(shared=False)

        # without shared parameter
        response = self.client.get(reverse("linkding:feeds.all", args=[self.token.key]))
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, "<item>", count=6)

        # with shared=yes
        response = self.client.get(
            reverse("linkding:feeds.all", args=[self.token.key]) + "?shared=yes"
        )
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, "<item>", count=2)

        # with shared=no
        response = self.client.get(
            reverse("linkding:feeds.all", args=[self.token.key]) + "?shared=no"
        )
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, "<item>", count=4)

    def test_with_tags(self):
        bookmarks = [
            self.setup_bookmark(description="test description"),
            self.setup_bookmark(
                description="test description",
                tags=[self.setup_tag(), self.setup_tag()],
            ),
        ]

        response = self.client.get(reverse("linkding:feeds.all", args=[self.token.key]))
        self.assertEqual(response.status_code, 200)
        self.assertFeedItems(response, bookmarks)

    def test_with_limit(self):
        self.setup_numbered_bookmarks(200)

        # without limit - defaults to 100
        response = self.client.get(reverse("linkding:feeds.all", args=[self.token.key]))
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, "<item>", count=100)

        # with increased limit
        response = self.client.get(
            reverse("linkding:feeds.all", args=[self.token.key]) + "?limit=200"
        )
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, "<item>", count=200)

        # with decreased limit
        response = self.client.get(
            reverse("linkding:feeds.all", args=[self.token.key]) + "?limit=5"
        )
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, "<item>", count=5)

    @unittest.skipIf(
        settings.LD_DB_ENGINE == "postgres",
        "Postgres does not allow NUL in text columns",
    )
    def test_strip_control_characters(self):
        self.setup_bookmark(
            title="test\n\r\t\0\x08title", description="test\n\r\t\0\x08description"
        )
        response = self.client.get(reverse("linkding:feeds.all", args=[self.token.key]))
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, "<item>", count=1)
        self.assertContains(response, "<title>test\n\r\ttitle</title>", count=1)
        self.assertContains(
            response, "<description>test\n\r\tdescription</description>", count=1
        )

    def test_sanitize_with_none_text(self):
        self.assertEqual("", sanitize(None))

    def test_with_bundle(self):
        tag1 = self.setup_tag()
        visible_bookmarks = [
            self.setup_bookmark(tags=[tag1]),
            self.setup_bookmark(tags=[tag1]),
        ]

        self.setup_bookmark()
        self.setup_bookmark()

        bundle = self.setup_bundle(all_tags=tag1.name)

        response = self.client.get(
            reverse("linkding:feeds.all", args=[self.token.key])
            + f"?bundle={bundle.id}"
        )
        self.assertEqual(response.status_code, 200)
        self.assertFeedItems(response, visible_bookmarks)

    def test_with_bundle_not_owned_by_user(self):
        other_user = User.objects.create_user(
            "otheruser", "otheruser@example.com", "password123"
        )
        other_bundle = self.setup_bundle(user=other_user, search="test")

        response = self.client.get(
            reverse("linkding:feeds.all", args=[self.token.key])
            + f"?bundle={other_bundle.id}"
        )
        self.assertEqual(response.status_code, 404)

    def test_with_invalid_bundle_id(self):
        self.setup_bookmark(title="test bookmark")

        response = self.client.get(
            reverse("linkding:feeds.all", args=[self.token.key]) + "?bundle=999999"
        )
        self.assertEqual(response.status_code, 404)

    def test_with_non_numeric_bundle_id(self):
        self.setup_bookmark(title="test bookmark")

        response = self.client.get(
            reverse("linkding:feeds.all", args=[self.token.key]) + "?bundle=invalid"
        )
        self.assertEqual(response.status_code, 404)


================================================
FILE: bookmarks/tests/test_feeds_performance.py
================================================
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.models import FeedToken, GlobalSettings
from bookmarks.tests.helpers import BookmarkFactoryMixin


class FeedsPerformanceTestCase(TestCase, BookmarkFactoryMixin):
    def setUp(self) -> None:
        user = self.get_or_create_test_user()
        self.client.force_login(user)
        self.token = FeedToken.objects.get_or_create(user=user)[0]

        # create global settings
        GlobalSettings.get()

    def get_connection(self):
        return connections[DEFAULT_DB_ALIAS]

    def test_all_max_queries(self):
        # set up some bookmarks with associated tags
        num_initial_bookmarks = 10
        for _ in range(num_initial_bookmarks):
            self.setup_bookmark(tags=[self.setup_tag()])

        # capture number of queries
        context = CaptureQueriesContext(self.get_connection())
        with context:
            feed_url = reverse("linkding:feeds.all", args=[self.token.key])
            self.client.get(feed_url)

        number_of_queries = context.final_queries

        self.assertLess(number_of_queries, num_initial_bookmarks)


================================================
FILE: bookmarks/tests/test_health_view.py
================================================
from unittest.mock import patch

from django.db import connections
from django.test import TestCase

from bookmarks.views.settings import app_version


class HealthViewTestCase(TestCase):
    def test_health_healthy(self):
        response = self.client.get("/health")

        self.assertEqual(response.status_code, 200)

        response_body = response.json()
        expected_body = {"version": app_version, "status": "healthy"}
        self.assertDictEqual(response_body, expected_body)

    def test_health_unhealhty(self):
        with patch.object(
            connections["default"], "ensure_connection"
        ) as mock_ensure_connection:
            mock_ensure_connection.side_effect = Exception("Connection error")

            response = self.client.get("/health")

            self.assertEqual(response.status_code, 500)

            response_body = response.json()
            expected_body = {"version": app_version, "status": "unhealthy"}
            self.assertDictEqual(response_body, expected_body)


================================================
FILE: bookmarks/tests/test_importer.py
================================================
from unittest.mock import patch

from django.test import TestCase, override_settings
from django.utils import timezone

from bookmarks.models import Bookmark, Tag, parse_tag_string
from bookmarks.services import tasks
from bookmarks.services.importer import ImportOptions, import_netscape_html
from bookmarks.tests.helpers import (
    BookmarkFactoryMixin,
    BookmarkHtmlTag,
    ImportTestMixin,
    disable_logging,
)
from bookmarks.utils import parse_timestamp


class ImporterTestCase(TestCase, BookmarkFactoryMixin, ImportTestMixin):
    def assertBookmarksImported(self, html_tags: list[BookmarkHtmlTag]):
        for html_tag in html_tags:
            bookmark = Bookmark.objects.get(url=html_tag.href)
            self.assertIsNotNone(bookmark)

            self.assertEqual(bookmark.title, html_tag.title)
            self.assertEqual(bookmark.description, html_tag.description)
            self.assertEqual(bookmark.date_added, parse_timestamp(html_tag.add_date))
            self.assertEqual(
                bookmark.date_modified, parse_timestamp(html_tag.last_modified)
            )
            self.assertEqual(bookmark.unread, html_tag.to_read)
            self.assertEqual(bookmark.shared, not html_tag.private)

            tag_names = parse_tag_string(html_tag.tags)

            # Check assigned tags
            for tag_name in tag_names:
                tag = next(
                    (tag for tag in bookmark.tags.all() if tag.name == tag_name), None
                )
                self.assertIsNotNone(tag)

    def test_import(self):
        html_tags = [
            BookmarkHtmlTag(
                href="https://example.com",
                title="Example title",
                description="Example description",
                add_date="1",
                last_modified="11",
                tags="example-tag",
            ),
            BookmarkHtmlTag(
                href="https://example.com/foo",
                title="Foo title",
                description="",
                add_date="2",
                last_modified="22",
                tags="",
            ),
            BookmarkHtmlTag(
                href="https://example.com/bar",
                title="Bar title",
                description="Bar description",
                add_date="3",
                last_modified="33",
                tags="bar-tag, other-tag",
            ),
            BookmarkHtmlTag(
                href="https://example.com/baz",
                title="Baz title",
                description="Baz description",
                add_date="4",
                last_modified="44",
                to_read=True,
            ),
        ]
        import_html = self.render_html(tags=html_tags)
        result = import_netscape_html(import_html, self.get_or_create_test_user())

        # Check result
        self.assertEqual(result.total, 4)
        self.assertEqual(result.success, 4)
        self.assertEqual(result.failed, 0)

        # Check bookmarks
        bookmarks = Bookmark.objects.all()
        self.assertEqual(len(bookmarks), 4)
        self.assertBookmarksImported(html_tags)

    def test_synchronize(self):
        # Initial import
        html_tags = [
            BookmarkHtmlTag(
                href="https://example.com",
                title="Example title",
                description="Example description",
                add_date="1",
                last_modified="11",
                tags="example-tag",
            ),
            BookmarkHtmlTag(
                href="https://example.com/foo",
                title="Foo title",
                description="",
                add_date="2",
                last_modified="22",
                tags="",
            ),
            BookmarkHtmlTag(
                href="https://example.com/bar",
                title="Bar title",
                description="Bar description",
                add_date="3",
                last_modified="33",
                tags="bar-tag, other-tag",
            ),
            BookmarkHtmlTag(
                href="https://example.com/unread",
                title="Unread title",
                description="Unread description",
                add_date="4",
                last_modified="44",
                to_read=True,
            ),
            BookmarkHtmlTag(
                href="https://example.com/private",
                title="Private title",
                description="Private description",
                add_date="5",
                last_modified="55",
                private=True,
            ),
        ]
        import_html = self.render_html(tags=html_tags)
        import_netscape_html(import_html, self.get_or_create_test_user())

        # Check bookmarks
        bookmarks = Bookmark.objects.all()
        self.assertEqual(len(bookmarks), 5)
        self.assertBookmarksImported(html_tags)

        # Change data, add some new data
        html_tags = [
            BookmarkHtmlTag(
                href="https://example.com",
                title="Updated Example title",
                description="Updated Example description",
                add_date="111",
                last_modified="1111",
                tags="updated-example-tag",
            ),
            BookmarkHtmlTag(
                href="https://example.com/foo",
                title="Updated Foo title",
                description="Updated Foo description",
                add_date="222",
                last_modified="2222",
                tags="new-tag",
            ),
            BookmarkHtmlTag(
                href="https://example.com/bar",
                title="Updated Bar title",
                description="Updated Bar description",
                add_date="333",
                last_modified="3333",
                tags="updated-bar-tag, updated-other-tag",
            ),
            BookmarkHtmlTag(
                href="https://example.com/unread",
                title="Unread title",
                description="Unread description",
                add_date="3",
                last_modified="3",
                to_read=False,
            ),
            BookmarkHtmlTag(
                href="https://example.com/private",
                title="Private title",
                description="Private description",
                add_date="4",
                last_modified="4",
                private=False,
            ),
            BookmarkHtmlTag(
                href="https://baz.com",
                add_date="444",
                last_modified="4444",
                tags="baz-tag",
            ),
        ]

        # Import updated data
        import_html = self.render_html(tags=html_tags)
        result = import_netscape_html(
            import_html,
            self.get_or_create_test_user(),
            ImportOptions(map_private_flag=True),
        )

        # Check result
        self.assertEqual(result.total, 6)
        self.assertEqual(result.success, 6)
        self.assertEqual(result.failed, 0)

        # Check bookmarks
        bookmarks = Bookmark.objects.all()
        self.assertEqual(len(bookmarks), 6)
        self.assertBookmarksImported(html_tags)

    def test_import_with_some_invalid_bookmarks(self):
        html_tags = [
            BookmarkHtmlTag(href="https://example.com"),
            # Invalid URL
            BookmarkHtmlTag(href="foo.com"),
            # No URL
            BookmarkHtmlTag(),
        ]
        import_html = self.render_html(tags=html_tags)
        result = import_netscape_html(import_html, self.get_or_create_test_user())

        # Check result
        self.assertEqual(result.total, 3)
        self.assertEqual(result.success, 1)
        self.assertEqual(result.failed, 2)

        # Check bookmarks
        bookmarks = Bookmark.objects.all()
        self.assertEqual(len(bookmarks), 1)
        self.assertBookmarksImported(html_tags[1:1])

    def test_import_invalid_bookmark_does_not_associate_tags(self):
        html_tags = [
            # No URL
            BookmarkHtmlTag(tags="tag1, tag2, tag3"),
        ]
        import_html = self.render_html(tags=html_tags)
        # Sqlite silently ignores relationships that have a non-persisted bookmark,
        # thus testing if the bulk create receives no relationships
        BookmarkToTagRelationShip = Bookmark.tags.through
        with patch.object(
            BookmarkToTagRelationShip.objects, "bulk_create"
        ) as mock_bulk_create:
            import_netscape_html(import_html, self.get_or_create_test_user())
            mock_bulk_create.assert_called_once_with([], ignore_conflicts=True)

    def test_import_tags(self):
        html_tags = [
            BookmarkHtmlTag(href="https://example.com", tags="tag1"),
            BookmarkHtmlTag(href="https://foo.com", tags="tag2"),
            BookmarkHtmlTag(href="https://bar.com", tags="tag3"),
        ]
        import_html = self.render_html(tags=html_tags)
        import_netscape_html(import_html, self.get_or_create_test_user())

        self.assertEqual(Tag.objects.count(), 3)

    def test_create_missing_tags(self):
        html_tags = [
            BookmarkHtmlTag(href="https://example.com", tags="tag1"),
            BookmarkHtmlTag(href="https://foo.com", tags="tag2"),
            BookmarkHtmlTag(href="https://bar.com", tags="tag3"),
        ]
        import_html = self.render_html(tags=html_tags)
        import_netscape_html(import_html, self.get_or_create_test_user())

        html_tags.append(BookmarkHtmlTag(href="https://baz.com", tags="tag4"))
        import_html = self.render_html(tags=html_tags)
        import_netscape_html(import_html, self.get_or_create_test_user())

        self.assertEqual(Tag.objects.count(), 4)

    def test_create_missing_tags_does_not_duplicate_tags(self):
        html_tags = [
            BookmarkHtmlTag(href="https://example.com", tags="tag1"),
            BookmarkHtmlTag(href="https://foo.com", tags="tag1"),
            BookmarkHtmlTag(href="https://bar.com", tags="tag1"),
        ]
        import_html = self.render_html(tags=html_tags)
        import_netscape_html(import_html, self.get_or_create_test_user())

        self.assertEqual(Tag.objects.count(), 1)

    def test_should_append_tags_to_bookmark_when_reimporting_with_different_tags(self):
        html_tags = [
            BookmarkHtmlTag(href="https://example.com", tags="tag1"),
        ]
        import_html = self.render_html(tags=html_tags)
        import_netscape_html(import_html, self.get_or_create_test_user())

        html_tags.append(BookmarkHtmlTag(href="https://example.com", tags="tag2, tag3"))
        import_html = self.render_html(tags=html_tags)
        import_netscape_html(import_html, self.get_or_create_test_user())

        self.assertEqual(Bookmark.objects.count(), 1)
        self.assertEqual(Bookmark.objects.all()[0].tags.all().count(), 3)

    @override_settings(USE_TZ=False)
    def test_use_current_date_when_no_add_date(self):
        test_html = self.render_html(
            tags_html="""
            <DT><A HREF="https://example.com">Example.com</A>
            <DD>Example.com
        """
        )

        with patch.object(timezone, "now", return_value=timezone.datetime(2021, 1, 1)):
            import_netscape_html(test_html, self.get_or_create_test_user())

            self.assertEqual(Bookmark.objects.count(), 1)
            self.assertEqual(
                Bookmark.objects.all()[0].date_added, timezone.datetime(2021, 1, 1)
            )

    def test_use_add_date_when_no_last_modified(self):
        test_html = self.render_html(
            tags_html="""
            <DT><A HREF="https://example.com" ADD_DATE="1">Example.com</A>
            <DD>Example.com
        """
        )

        import_netscape_html(test_html, self.get_or_create_test_user())

        self.assertEqual(Bookmark.objects.count(), 1)
        self.assertEqual(Bookmark.objects.all()[0].date_modified, parse_timestamp("1"))

    def test_keep_title_if_imported_bookmark_has_empty_title(self):
        test_html = self.render_html(
            tags=[BookmarkHtmlTag(href="https://example.com", title="Example.com")]
        )
        import_netscape_html(test_html, self.get_or_create_test_user())

        test_html = self.render_html(tags=[BookmarkHtmlTag(href="https://example.com")])
        import_netscape_html(test_html, self.get_or_create_test_user())

        self.assertEqual(Bookmark.objects.count(), 1)
        self.assertEqual(Bookmark.objects.all()[0].title, "Example.com")

    def test_keep_description_if_imported_bookmark_has_empty_description(self):
        test_html = self.render_html(
            tags=[
                BookmarkHtmlTag(href="https://example.com", description="Example.com")
            ]
        )
        import_netscape_html(test_html, self.get_or_create_test_user())

        test_html = self.render_html(tags=[BookmarkHtmlTag(href="https://example.com")])
        import_netscape_html(test_html, self.get_or_create_test_user())

        self.assertEqual(Bookmark.objects.count(), 1)
        self.assertEqual(Bookmark.objects.all()[0].description, "Example.com")

    def test_replace_whitespace_in_tag_names(self):
        test_html = self.render_html(
            tags_html="""
            <DT><A HREF="https://example.com" TAGS="tag 1, tag 2, tag 3">Example.com</A>
            <DD>Example.com
        """
        )
        import_netscape_html(test_html, self.get_or_create_test_user())

        tags = Tag.objects.all()
        tag_names = [tag.name for tag in tags]

        self.assertListEqual(tag_names, ["tag-1", "tag-2", "tag-3"])

    def test_ignore_long_tag_names(self):
        long_tag = "a" * 65
        valid_tag = "valid-tag"

        test_html = self.render_html(
            tags_html=f"""
            <DT><A HREF="https://example.com" TAGS="{long_tag}, {valid_tag}">Example.com</A>
            <DD>Example.com
        """
        )
        result = import_netscape_html(test_html, self.get_or_create_test_user())

        # Import should succeed
        self.assertEqual(result.success, 1)
        self.assertEqual(result.failed, 0)

        # Only the valid tag should be created
        tags = Tag.objects.all()
        self.assertEqual(len(tags), 1)
        self.assertEqual(tags[0].name, valid_tag)

        # Bookmark should only have the valid tag assigned
        bookmark = Bookmark.objects.get(url="https://example.com")
        bookmark_tag_names = [tag.name for tag in bookmark.tags.all()]
        self.assertEqual(bookmark_tag_names, [valid_tag])

    @disable_logging
    def test_validate_empty_or_missing_bookmark_url(self):
        test_html = self.render_html(
            tags_html="""
            <DT><A HREF="">Empty URL</A>
            <DD>Empty URL
            <DT><A>Missing URL</A>
            <DD>Missing URL
        """
        )

        import_result = import_netscape_html(test_html, self.get_or_create_test_user())

        self.assertEqual(Bookmark.objects.count(), 0)
        self.assertEqual(import_result.success, 0)
        self.assertEqual(import_result.failed, 2)

    def test_generate_normalized_url(self):
        html_tags = [
            BookmarkHtmlTag(href="https://example.com/?z=1&a=2#"),
            BookmarkHtmlTag(
                href="foo.bar"
            ),  # invalid URL, should be skipped without error
        ]
        import_html = self.render_html(tags=html_tags)
        import_netscape_html(import_html, self.get_or_create_test_user())

        self.assertEqual(Bookmark.objects.count(), 1)
        self.assertEqual(
            Bookmark.objects.all()[0].url_normalized, "https://example.com?a=2&z=1"
        )

    def test_private_flag(self):
        # does not map private flag if not enabled in options
        test_html = self.render_html(
            tags_html="""
        <DT><A HREF="https://example.com/1" ADD_DATE="1">Example title 1</A>
        <DD>Example description 1</DD>
        <DT><A HREF="https://example.com/2" ADD_DATE="1" PRIVATE="1">Example title 2</A>
        <DD>Example description 2</DD>
        <DT><A HREF="https://example.com/3" ADD_DATE="1" PRIVATE="0">Example title 3</A>
        <DD>Example description 3</DD>
        """
        )
        import_netscape_html(test_html, self.get_or_create_test_user(), ImportOptions())

        self.assertEqual(Bookmark.objects.count(), 3)
        self.assertEqual(Bookmark.objects.all()[0].shared, False)
        self.assertEqual(Bookmark.objects.all()[1].shared, False)
        self.assertEqual(Bookmark.objects.all()[2].shared, False)

        # does map private flag if enabled in options
        Bookmark.objects.all().delete()
        import_netscape_html(
            test_html,
            self.get_or_create_test_user(),
            ImportOptions(map_private_flag=True),
        )
        bookmark1 = Bookmark.objects.get(url="https://example.com/1")
        bookmark2 = Bookmark.objects.get(url="https://example.com/2")
        bookmark3 = Bookmark.objects.get(url="https://example.com/3")
        self.assertEqual(bookmark1.shared, False)
        self.assertEqual(bookmark2.shared, False)
        self.assertEqual(bookmark3.shared, True)

    def test_archived_state(self):
        test_html = self.render_html(
            tags_html="""
        <DT><A HREF="https://example.com/1" ADD_DATE="1" TAGS="tag1,tag2,linkding:bookmarks.archived">Example title 1</A>
        <DD>Example description 1</DD>
        <DT><A HREF="https://example.com/2" ADD_DATE="1" PRIVATE="1" TAGS="tag1,tag2">Example title 2</A>
        <DD>Example description 2</DD>
        <DT><A HREF="https://example.com/3" ADD_DATE="1" PRIVATE="0">Example title 3</A>
        <DD>Example description 3</DD>
        """
        )
        import_netscape_html(test_html, self.get_or_create_test_user(), ImportOptions())

        self.assertEqual(Bookmark.objects.count(), 3)
        self.assertEqual(Bookmark.objects.all()[0].is_archived, True)
        self.assertEqual(Bookmark.objects.all()[1].is_archived, False)
        self.assertEqual(Bookmark.objects.all()[2].is_archived, False)

        tags = Tag.objects.all()
        self.assertEqual(len(tags), 2)
        self.assertEqual(tags[0].name, "tag1")
        self.assertEqual(tags[1].name, "tag2")

    def test_notes(self):
        # initial notes
        test_html = self.render_html(
            tags_html="""
        <DT><A HREF="https://example.com" ADD_DATE="1">Example title</A>
        <DD>Example description[linkding-notes]Example notes[/linkding-notes]
        """
        )
        import_netscape_html(test_html, self.get_or_create_test_user(), ImportOptions())

        self.assertEqual(Bookmark.objects.count(), 1)
        self.assertEqual(Bookmark.objects.all()[0].description, "Example description")
        self.assertEqual(Bookmark.objects.all()[0].notes, "Example notes")

        # update notes
        test_html = self.render_html(
            tags_html="""
        <DT><A HREF="https://example.com" ADD_DATE="1">Example title</A>
        <DD>Example description[linkding-notes]Updated notes[/linkding-notes]
        """
        )
        import_netscape_html(test_html, self.get_or_create_test_user(), ImportOptions())

        self.assertEqual(Bookmark.objects.count(), 1)
        self.assertEqual(Bookmark.objects.all()[0].description, "Example description")
        self.assertEqual(Bookmark.objects.all()[0].notes, "Updated notes")

        # does not override existing notes if empty
        test_html = self.render_html(
            tags_html="""
        <DT><A HREF="https://example.com" ADD_DATE="1">Example title</A>
        <DD>Example description
        """
        )
        import_netscape_html(test_html, self.get_or_create_test_user(), ImportOptions())

        self.assertEqual(Bookmark.objects.count(), 1)
        self.assertEqual(Bookmark.objects.all()[0].description, "Example description")
        self.assertEqual(Bookmark.objects.all()[0].notes, "Updated notes")

    def test_schedule_favicon_loading(self):
        user = self.get_or_create_test_user()
        test_html = self.render_html(tags_html="")

        with patch.object(
            tasks, "schedule_bookmarks_without_favicons"
        ) as mock_schedule_bookmarks_without_favicons:
            import_netscape_html(test_html, user)

            mock_schedule_bookmarks_without_favicons.assert_called_once_with(user)

    def test_schedule_preview_loading(self):
        user = self.get_or_create_test_user()
        test_html = self.render_html(tags_html="")

        with patch.object(
            tasks, "schedule_bookmarks_without_previews"
        ) as mock_schedule_bookmarks_without_previews:
            import_netscape_html(test_html, user)

            mock_schedule_bookmarks_without_previews.assert_called_once_with(user)


================================================
FILE: bookmarks/tests/test_layout.py
================================================
from django.test import TestCase
from django.urls import reverse

from bookmarks.models import GlobalSettings
from bookmarks.tests.helpers import BookmarkFactoryMixin, HtmlTestMixin


class LayoutTestCase(TestCase, BookmarkFactoryMixin, HtmlTestMixin):
    def setUp(self) -> None:
        user = self.get_or_create_test_user()
        self.client.force_login(user)

    def test_nav_menu_should_respect_share_profile_setting(self):
        self.user.profile.enable_sharing = False
        self.user.profile.save()
        response = self.client.get(reverse("linkding:bookmarks.index"))
        html = response.content.decode()

        self.assertInHTML(
            f"""
            <a href="{reverse("linkding:bookmarks.shared")}" class="menu-link">Shared</a>
        """,
            html,
            count=0,
        )
        self.assertInHTML(
            f"""
            <a href="{reverse("linkding:bookmarks.shared")}" class="menu-link">Shared bookmarks</a>
        """,
            html,
            count=0,
        )

        self.user.profile.enable_sharing = True
        self.user.profile.save()
        response = self.client.get(reverse("linkding:bookmarks.index"))
        html = response.content.decode()

        self.assertInHTML(
            f"""
            <a href="{reverse("linkding:bookmarks.shared")}" class="menu-link">Shared</a>
        """,
            html,
            count=1,
        )
        self.assertInHTML(
            f"""
            <a href="{reverse("linkding:bookmarks.shared")}" class="menu-link">Shared bookmarks</a>
        """,
            html,
            count=1,
        )

    def test_metadata_should_respect_prefetch_links_setting(self):
        settings = GlobalSettings.get()
        settings.enable_link_prefetch = False
        settings.save()

        response = self.client.get(reverse("linkding:bookmarks.index"))
        html = response.content.decode()

        self.assertInHTML(
            '<meta name="turbo-prefetch" content="false">',
            html,
            count=1,
        )

        settings.enable_link_prefetch = True
        settings.save()

        response = self.client.get(reverse("linkding:bookmarks.index"))
        html = response.content.decode()

        self.assertInHTML(
            '<meta name="turbo-prefetch" content="false">',
            html,
            count=0,
        )

    def test_does_not_link_custom_css_when_empty(self):
        response = self.client.get(reverse("linkding:bookmarks.index"))
        html = response.content.decode()
        soup = self.make_soup(html)

        link = soup.select_one("link[rel='stylesheet'][href*='custom_css']")
        self.assertIsNone(link)

    def test_does_link_custom_css_when_not_empty(self):
        profile = self.get_or_create_test_user().profile
        profile.custom_css = "body { background-color: red; }"
        profile.save()

        response = self.client.get(reverse("linkding:bookmarks.index"))
        html = response.content.decode()
        soup = self.make_soup(html)

        link = soup.select_one("link[rel='stylesheet'][href*='custom_css']")
        self.assertIsNotNone(link)

    def test_custom_css_link_href(self):
        profile = self.get_or_create_test_user().profile
        profile.custom_css = "body { background-color: red; }"
        profile.save()

        response = self.client.get(reverse("linkding:bookmarks.index"))
        html = response.content.decode()
        soup = self.make_soup(html)

        link = soup.select_one("link[rel='stylesheet'][href*='custom_css']")
        expected_url = (
            reverse("linkding:custom_css") + f"?hash={profile.custom_css_hash}"
        )
        self.assertEqual(link["href"], expected_url)


================================================
FILE: bookmarks/tests/test_linkding_middleware.py
================================================
from django.test import TestCase
from django.urls import reverse

from bookmarks.middlewares import standard_profile
from bookmarks.models import GlobalSettings, UserProfile
from bookmarks.tests.helpers import BookmarkFactoryMixin


class LinkdingMiddlewareTestCase(TestCase, BookmarkFactoryMixin):
    def test_unauthenticated_user_should_use_standard_profile_by_default(self):
        response = self.client.get(reverse("login"))

        self.assertEqual(standard_profile, response.wsgi_request.user_profile)

    def test_unauthenticated_user_should_use_custom_configured_profile(self):
        guest_user = self.setup_user()
        guest_user_profile = guest_user.profile
        guest_user_profile.theme = UserProfile.THEME_DARK
        guest_user_profile.save()

        global_settings = GlobalSettings.get()
        global_settings.guest_profile_user = guest_user
        global_settings.save()

        response = self.client.get(reverse("login"))

        self.assertEqual(guest_user_profile, response.wsgi_request.user_profile)

    def test_authenticated_user_should_use_own_profile(self):
        guest_user = self.setup_user()
        guest_user_profile = guest_user.profile
        guest_user_profile.theme = UserProfile.THEME_DARK
        guest_user_profile.save()

        global_settings = GlobalSettings.get()
        global_settings.guest_profile_user = guest_user
        global_settings.save()

        user = self.get_or_create_test_user()
        user_profile = user.profile
        user_profile.theme = UserProfile.THEME_LIGHT
        user_profile.save()
        self.client.force_login(user)

        response = self.client.get(reverse("login"), follow=True)

        self.assertEqual(user_profile, response.wsgi_request.user_profile)


================================================
FILE: bookmarks/tests/test_login_view.py
================================================
from django.test import TestCase, override_settings
from django.urls import include, path

from bookmarks.tests.helpers import BookmarkFactoryMixin, HtmlTestMixin
from bookmarks.urls import urlpatterns as base_patterns

# Register OIDC urls for this test, otherwise login template can not render when OIDC is enabled
urlpatterns = base_patterns + [path("oidc/", include("mozilla_django_oidc.urls"))]


@override_settings(ROOT_URLCONF=__name__)
class LoginViewTestCase(TestCase, BookmarkFactoryMixin, HtmlTestMixin):
    def test_failed_login_should_return_401(self):
        response = self.client.post("/login/", {"username": "test", "password": "test"})
        self.assertEqual(response.status_code, 401)

    def test_successful_login_should_redirect(self):
        user = self.setup_user(name="test")
        user.set_password("test")
        user.save()

        response = self.client.post("/login/", {"username": "test", "password": "test"})
        self.assertEqual(response.status_code, 302)

    def test_should_not_show_oidc_login_by_default(self):
        response = self.client.get("/login/")
        soup = self.make_soup(response.content.decode())

        oidc_login_link = soup.find("a", string="Login with OIDC")

        self.assertIsNone(oidc_login_link)

    @override_settings(LD_ENABLE_OIDC=True)
    def test_should_show_oidc_login_when_enabled(self):
        response = self.client.get("/login/")
        soup = self.make_soup(response.content.decode())

        oidc_login_link = soup.find("a", string="Login with OIDC")

        self.assertIsNotNone(oidc_login_link)

        # should have turbo disabled
        self.assertEqual("false", oidc_login_link.get("data-turbo"))

    def test_should_show_login_form_by_default(self):
        response = self.client.get("/login/")
        soup = self.make_soup(response.content.decode())

        form = soup.find("form", {"action": "/login/"})
        username_input = soup.find("input", {"name": "username"})
        password_input = soup.find("input", {"name": "password"})
        submit_button = soup.find("input", {"type": "submit", "value": "Login"})

        self.assertIsNotNone(form)
        self.assertIsNotNone(username_input)
        self.assertIsNotNone(password_input)
        self.assertIsNotNone(submit_button)

    @override_settings(LD_DISABLE_LOGIN_FORM=True)
    def test_should_hide_login_form_when_disabled(self):
        response = self.client.get("/login/")
        soup = self.make_soup(response.content.decode())

        form = soup.find("form", {"action": "/login/"})
        username_input = soup.find("input", {"name": "username"})
        password_input = soup.find("input", {"name": "password"})
        submit_button = soup.find("input", {"type": "submit", "value": "Login"})

        self.assertIsNone(form)
        self.assertIsNone(username_input)
        self.assertIsNone(password_input)
        self.assertIsNone(submit_button)

    @override_settings(LD_DISABLE_LOGIN_FORM=True, LD_ENABLE_OIDC=True)
    def test_should_only_show_oidc_login_when_login_disabled_and_oidc_enabled(self):
        response = self.client.get("/login/")
        soup = self.make_soup(response.content.decode())

        form = soup.find("form", {"action": "/login/"})
        oidc_login_link = soup.find("a", string="Login with OIDC")

        self.assertIsNone(form)
        self.assertIsNotNone(oidc_login_link)


================================================
FILE: bookmarks/tests/test_metadata_view.py
================================================
from django.test import TestCase, override_settings


class MetadataViewTestCase(TestCase):
    def test_default_manifest(self):
        response = self.client.get("/manifest.json")

        self.assertEqual(response.status_code, 200)

        response_body = response.json()
        expected_body = {
            "short_name": "linkding",
            "name": "linkding",
            "description": "Self-hosted bookmark service",
            "start_url": "bookmarks",
            "display": "standalone",
            "scope": "/",
            "theme_color": "#5856e0",
            "background_color": "#ffffff",
            "icons": [
                {
                    "src": "/static/logo.svg",
                    "type": "image/svg+xml",
                    "sizes": "512x512",
                    "purpose": "any",
                },
                {
                    "src": "/static/logo-512.png",
                    "type": "image/png",
                    "sizes": "512x512",
                    "purpose": "any",
                },
                {
                    "src": "/static/logo-192.png",
                    "type": "image/png",
                    "sizes": "192x192",
                    "purpose": "any",
                },
                {
                    "src": "/static/maskable-logo.svg",
                    "type": "image/svg+xml",
                    "sizes": "512x512",
                    "purpose": "maskable",
                },
                {
                    "src": "/static/maskable-logo-512.png",
                    "type": "image/png",
                    "sizes": "512x512",
                    "purpose": "maskable",
                },
                {
                    "src": "/static/maskable-logo-192.png",
                    "type": "image/png",
                    "sizes": "192x192",
                    "purpose": "maskable",
                },
            ],
            "shortcuts": [
                {
                    "name": "Add bookmark",
                    "url": "/bookmarks/new",
                },
                {
                    "name": "Archived",
                    "url": "/bookmarks/archived",
                },
                {
                    "name": "Unread",
                    "url": "/bookmarks?unread=yes",
                },
                {
                    "name": "Untagged",
                    "url": "/bookmarks?q=!untagged",
                },
                {
                    "name": "Shared",
                    "url": "/bookmarks/shared",
                },
            ],
            "screenshots": [
                {
                    "src": "/static/linkding-screenshot.png",
                    "type": "image/png",
                    "sizes": "2158x1160",
                    "form_factor": "wide",
                }
            ],
            "share_target": {
                "action": "/bookmarks/new",
                "method": "GET",
                "enctype": "application/x-www-form-urlencoded",
                "params": {
                    "url": "url",
                    "text": "url",
                    "title": "title",
                },
            },
        }
        self.assertDictEqual(response_body, expected_body)

    @override_settings(LD_CONTEXT_PATH="linkding/")
    def test_manifest_respects_context_path(self):
        response = self.client.get("/manifest.json")

        self.assertEqual(response.status_code, 200)

        response_body = response.json()
        expected_body = {
            "short_name": "linkding",
            "name": "linkding",
            "description": "Self-hosted bookmark service",
            "start_url": "bookmarks",
            "display": "standalone",
            "scope": "/linkding/",
            "theme_color": "#5856e0",
            "background_color": "#ffffff",
            "icons": [
                {
                    "src": "/linkding/static/logo.svg",
                    "type": "image/svg+xml",
                    "sizes": "512x512",
                    "purpose": "any",
                },
                {
                    "src": "/linkding/static/logo-512.png",
                    "type": "image/png",
                    "sizes": "512x512",
                    "purpose": "any",
                },
                {
                    "src": "/linkding/static/logo-192.png",
                    "type": "image/png",
                    "sizes": "192x192",
                    "purpose": "any",
                },
                {
                    "src": "/linkding/static/maskable-logo.svg",
                    "type": "image/svg+xml",
                    "sizes": "512x512",
                    "purpose": "maskable",
                },
                {
                    "src": "/linkding/static/maskable-logo-512.png",
                    "type": "image/png",
                    "sizes": "512x512",
                    "purpose": "maskable",
                },
                {
                    "src": "/linkding/static/maskable-logo-192.png",
                    "type": "image/png",
                    "sizes": "192x192",
                    "purpose": "maskable",
                },
            ],
            "shortcuts": [
                {
                    "name": "Add bookmark",
                    "url": "/linkding/bookmarks/new",
                },
                {
                    "name": "Archived",
                    "url": "/linkding/bookmarks/archived",
                },
                {
                    "name": "Unread",
                    "url": "/linkding/bookmarks?unread=yes",
                },
                {
                    "name": "Untagged",
                    "url": "/linkding/bookmarks?q=!untagged",
                },
                {
                    "name": "Shared",
                    "url": "/linkding/bookmarks/shared",
                },
            ],
            "screenshots": [
                {
                    "src": "/linkding/static/linkding-screenshot.png",
                    "type": "image/png",
                    "sizes": "2158x1160",
                    "form_factor": "wide",
                }
            ],
            "share_target": {
                "action": "/linkding/bookmarks/new",
                "method": "GET",
                "enctype": "application/x-www-form-urlencoded",
                "params": {
                    "url": "url",
                    "text": "url",
                    "title": "title",
                },
            },
        }
        self.assertDictEqual(response_body, expected_body)


================================================
FILE: bookmarks/tests/test_monolith_service.py
================================================
import gzip
import os
import subprocess
from unittest import mock

from django.test import TestCase

from bookmarks.services import monolith


class MonolithServiceTestCase(TestCase):
    html_content = "<html><body><h1>Hello, World!</h1></body></html>"
    html_filepath = "temp.html.gz"
    temp_html_filepath = "temp.html.gz.tmp"

    def tearDown(self):
        if os.path.exists(self.html_filepath):
            os.remove(self.html_filepath)
        if os.path.exists(self.temp_html_filepath):
            os.remove(self.temp_html_filepath)

    def create_test_file(self, *args, **kwargs):
        with open(self.temp_html_filepath, "w") as file:
            file.write(self.html_content)

    def test_create_snapshot(self):
        with mock.patch("subprocess.run") as mock_run:
            mock_run.side_effect = self.create_test_file

            monolith.create_snapshot("http://example.com", self.html_filepath)

            self.assertTrue(os.path.exists(self.html_filepath))
            self.assertFalse(os.path.exists(self.temp_html_filepath))

            with gzip.open(self.html_filepath, "rt") as file:
                content = file.read()
                self.assertEqual(content, self.html_content)

    def test_create_snapshot_failure(self):
        with mock.patch("subprocess.run") as mock_run:
            mock_run.side_effect = subprocess.CalledProcessError(1, "command")

            with self.assertRaises(monolith.MonolithError):
                monolith.create_snapshot("http://example.com", self.html_filepath)


================================================
FILE: bookmarks/tests/test_oidc_support.py
================================================
import importlib
import os

from django.test import TestCase, override_settings
from django.urls import URLResolver

from bookmarks import utils


class OidcSupportTest(TestCase):
    def test_should_not_add_oidc_urls_by_default(self):
        urls_module = importlib.import_module("bookmarks.urls")
        importlib.reload(urls_module)
        oidc_url_found = any(
            isinstance(urlpattern, URLResolver) and urlpattern.pattern._route == "oidc/"
            for urlpattern in urls_module.urlpatterns
        )

        self.assertFalse(oidc_url_found)

    @override_settings(LD_ENABLE_OIDC=True)
    def test_should_add_oidc_urls_when_enabled(self):
        urls_module = importlib.import_module("bookmarks.urls")
        importlib.reload(urls_module)
        oidc_url_found = any(
            isinstance(urlpattern, URLResolver) and urlpattern.pattern._route == "oidc/"
            for urlpattern in urls_module.urlpatterns
        )

        self.assertTrue(oidc_url_found)

    def test_should_not_add_oidc_authentication_backend_by_default(self):
        base_settings = importlib.import_module("bookmarks.settings.base")
        importlib.reload(base_settings)

        self.assertListEqual(
            ["django.contrib.auth.backends.ModelBackend"],
            base_settings.AUTHENTICATION_BACKENDS,
        )

    def test_should_add_oidc_authentication_backend_when_enabled(self):
        os.environ["LD_ENABLE_OIDC"] = "True"
        base_settings = importlib.import_module("bookmarks.settings.base")
        importlib.reload(base_settings)

        self.assertListEqual(
            [
                "django.contrib.auth.backends.ModelBackend",
                "mozilla_django_oidc.auth.OIDCAuthenticationBackend",
            ],
            base_settings.AUTHENTICATION_BACKENDS,
        )
        del os.environ["LD_ENABLE_OIDC"]  # Remove the temporary environment variable

    def test_default_settings(self):
        os.environ["LD_ENABLE_OIDC"] = "True"
        base_settings = importlib.import_module("bookmarks.settings.base")
        importlib.reload(base_settings)

        self.assertEqual(True, base_settings.OIDC_VERIFY_SSL)
        self.assertEqual("openid email profile", base_settings.OIDC_RP_SCOPES)
        self.assertEqual("email", base_settings.OIDC_USERNAME_CLAIM)

        del os.environ["LD_ENABLE_OIDC"]  # Remove the temporary environment variable

    @override_settings(LD_ENABLE_OIDC=True, OIDC_USERNAME_CLAIM="email")
    def test_username_should_use_email_by_default(self):
        claims = {
            "email": "test@example.com",
            "name": "test name",
            "given_name": "test given name",
            "preferred_username": "test preferred username",
            "nickname": "test nickname",
            "groups": [],
        }

        username = utils.generate_username(claims["email"], claims)

        self.assertEqual(claims["email"], username)

    @override_settings(LD_ENABLE_OIDC=True, OIDC_USERNAME_CLAIM="preferred_username")
    def test_username_should_use_custom_claim(self):
        claims = {
            "email": "test@example.com",
            "name": "test name",
            "given_name": "test given name",
            "preferred_username": "test preferred username",
            "nickname": "test nickname",
            "groups": [],
        }

        username = utils.generate_username(claims["email"], claims)

        self.assertEqual(claims["preferred_username"], username)

    @override_settings(LD_ENABLE_OIDC=True, OIDC_USERNAME_CLAIM="nonexistant_claim")
    def test_username_should_fallback_to_email_for_non_existing_claim(self):
        claims = {
            "email": "test@example.com",
            "name": "test name",
            "given_name": "test given name",
            "preferred_username": "test preferred username",
            "nickname": "test nickname",
            "groups": [],
        }

        username = utils.generate_username(claims["email"], claims)

        self.assertEqual(claims["email"], username)

    @override_settings(LD_ENABLE_OIDC=True, OIDC_USERNAME_CLAIM="preferred_username")
    def test_username_should_fallback_to_email_for_empty_claim(self):
        claims = {
            "email": "test@example.com",
            "name": "test name",
            "given_name": "test given name",
            "preferred_username": "",
            "nickname": "test nickname",
            "groups": [],
        }

        username = utils.generate_username(claims["email"], claims)

        self.assertEqual(claims["email"], username)

    @override_settings(LD_ENABLE_OIDC=True, OIDC_USERNAME_CLAIM="preferred_username")
    def test_username_should_be_normalized(self):
        claims = {
            "email": "test@example.com",
            "name": "test name",
            "given_name": "test given name",
            "preferred_username": "ＮｏｒｍａｌｉｚｅｄＵｓｅｒ",
            "nickname": "test nickname",
            "groups": [],
        }

        username = utils.generate_username(claims["email"], claims)

        self.assertEqual("NormalizedUser", username)


================================================
FILE: bookmarks/tests/test_opensearch_view.py
================================================
from django.test import TestCase
from django.urls import reverse


class OpenSearchViewTestCase(TestCase):
    def test_opensearch_configuration(self):
        response = self.client.get(reverse("linkding:opensearch"))
        self.assertEqual(response.status_code, 200)
        self.assertEqual(
            response["content-type"], "application/opensearchdescription+xml"
        )

        base_url = "http://testserver"
        expected_content = f"""
            <OpenSearchDescription xmlns="http://a9.com/-/spec/opensearch/1.1/" xmlns:moz="http://www.mozilla.org/2006/browser/search/">
                <ShortName>Linkding</ShortName>
                <Description>Linkding</Description>
                <InputEncoding>UTF-8</InputEncoding>
                <Image width="16" height="16" type="image/x-icon">{base_url}/static/favicon.ico</Image>
                <Url type="text/html" template="{base_url}/bookmarks?client=opensearch&amp;q={{searchTerms}}"/>
            </OpenSearchDescription>
        """
        content = response.content.decode()
        self.assertXMLEqual(content, expected_content)


================================================
FILE: bookmarks/tests/test_pagination_tag.py
================================================
from django.core.paginator import Paginator
from django.template import RequestContext, Template
from django.test import RequestFactory, TestCase

from bookmarks.tests.helpers import BookmarkFactoryMixin


class PaginationTagTest(TestCase, BookmarkFactoryMixin):
    def render_template(
        self,
        num_items: int,
        page_size: int,
        current_page: int,
        url: str = "/test",
        frame: str = None,
    ) -> str:
        rf = RequestFactory()
        request = rf.get(url)
        request.user = self.get_or_create_test_user()
        request.user_profile = self.get_or_create_test_user().profile
        paginator = Paginator(range(0, num_items), page_size)
        page = paginator.page(current_page)

        context_dict = {"page": page}
        if frame:
            context_dict["pagination_frame"] = frame
        context = RequestContext(request, context_dict)

        template_to_render = Template("{% load pagination %}{% pagination page %}")
        return template_to_render.render(context)

    def assertPrevLinkDisabled(self, html: str):
        self.assertInHTML(
            """
            <li class="page-item disabled">
                <a href="#" tabindex="-1">Previous</a>
            </li>
            """,
            html,
        )

    def assertPrevLink(
        self, html: str, page_number: int, href: str = None, frame: str = "_top"
    ):
        href = href if href else f"/test?page={page_number}"
        self.assertInHTML(
            f"""
            <li class="page-item">
                <a href="{href}" tabindex="-1" data-turbo-frame="{frame}">Previous</a>
            </li>
            """,
            html,
        )

    def assertNextLinkDisabled(self, html: str):
        self.assertInHTML(
            """
            <li class="page-item disabled">
                <a href="#" tabindex="-1">Next</a>
            </li>
            """,
            html,
        )

    def assertNextLink(
        self, html: str, page_number: int, href: str = None, frame: str = "_top"
    ):
        href = href if href else f"/test?page={page_number}"
        self.assertInHTML(
            f"""
            <li class="page-item">
                <a href="{href}" tabindex="-1" data-turbo-frame="{frame}">Next</a>
            </li>
            """,
            html,
        )

    def assertPageLink(
        self,
        html: str,
        page_number: int,
        active: bool,
        count: int = 1,
        href: str = None,
        frame: str = "_top",
    ):
        active_class = "active" if active else ""
        href = href if href else f"/test?page={page_number}"
        self.assertInHTML(
            f"""
            <li class="page-item {active_class}">
                <a href="{href}" data-turbo-frame="{frame}">{page_number}</a>
            </li>
            """,
            html,
            count=count,
        )

    def assertTruncationIndicators(self, html: str, count: int):
        self.assertInHTML(
            """
            <li class="page-item">
                <span>...</span>
            </li>
            """,
            html,
            count=count,
        )

    def test_previous_disabled_on_page_1(self):
        rendered_template = self.render_template(100, 10, 1)
        self.assertPrevLinkDisabled(rendered_template)

    def test_previous_enabled_after_page_1(self):
        for page_number in range(2, 10):
            rendered_template = self.render_template(100, 10, page_number)
            self.assertPrevLink(rendered_template, page_number - 1)

    def test_next_disabled_on_last_page(self):
        rendered_template = self.render_template(100, 10, 10)
        self.assertNextLinkDisabled(rendered_template)

    def test_next_enabled_before_last_page(self):
        for page_number in range(1, 9):
            rendered_template = self.render_template(100, 10, page_number)
            self.assertNextLink(rendered_template, page_number + 1)

    def test_truncate_pages_start(self):
        current_page = 1
        expected_visible_pages = [1, 2, 3, 10]
        rendered_template = self.render_template(100, 10, current_page)
        for page_number in range(1, 10):
            expected_occurrences = 1 if page_number in expected_visible_pages else 0
            self.assertPageLink(
                rendered_template,
                page_number,
                page_number == current_page,
                expected_occurrences,
            )
        self.assertTruncationIndicators(rendered_template, 1)

    def test_truncate_pages_middle(self):
        current_page = 5
        expected_visible_pages = [1, 3, 4, 5, 6, 7, 10]
        rendered_template = self.render_template(100, 10, current_page)
        for page_number in range(1, 10):
            expected_occurrences = 1 if page_number in expected_visible_pages else 0
            self.assertPageLink(
                rendered_template,
                page_number,
                page_number == current_page,
                expected_occurrences,
            )
        self.assertTruncationIndicators(rendered_template, 2)

    def test_truncate_pages_near_end(self):
        current_page = 9
        expected_visible_pages = [1, 7, 8, 9, 10]
        rendered_template = self.render_template(100, 10, current_page)
        for page_number in range(1, 10):
            expected_occurrences = 1 if page_number in expected_visible_pages else 0
            self.assertPageLink(
                rendered_template,
                page_number,
                page_number == current_page,
                expected_occurrences,
            )
        self.assertTruncationIndicators(rendered_template, 1)

    def test_respects_search_parameters(self):
        rendered_template = self.render_template(
            100, 10, 2, url="/test?q=cake&sort=title_asc&page=2"
        )
        self.assertPrevLink(
            rendered_template,
            1,
            href="/test?q=cake&sort=title_asc&page=1",
        )
        self.assertPageLink(
            rendered_template,
            1,
            False,
            href="/test?q=cake&sort=title_asc&page=1",
        )
        self.assertPageLink(
            rendered_template,
            2,
            True,
            href="/test?q=cake&sort=title_asc&page=2",
        )
        self.assertNextLink(
            rendered_template,
            3,
            href="/test?q=cake&sort=title_asc&page=3",
        )

    def test_removes_details_parameter(self):
        rendered_template = self.render_template(
            100, 10, 2, url="/test?details=1&page=2"
        )
        self.assertPrevLink(rendered_template, 1, href="/test?page=1")
        self.assertPageLink(rendered_template, 1, False, href="/test?page=1")
        self.assertPageLink(rendered_template, 2, True, href="/test?page=2")
        self.assertNextLink(rendered_template, 3, href="/test?page=3")

    def test_respects_pagination_frame(self):
        rendered_template = self.render_template(100, 10, 2, frame="my_frame")
        self.assertPrevLink(rendered_template, 1, frame="my_frame")
        self.assertPageLink(rendered_template, 1, False, frame="my_frame")
        self.assertPageLink(rendered_template, 2, True, frame="my_frame")
        self.assertNextLink(rendered_template, 3, frame="my_frame")


================================================
FILE: bookmarks/tests/test_parser.py
================================================
from django.test import TestCase

from bookmarks.models import parse_tag_string
from bookmarks.services.parser import NetscapeBookmark, parse
from bookmarks.tests.helpers import BookmarkHtmlTag, ImportTestMixin


class ParserTestCase(TestCase, ImportTestMixin):
    def assertTagsEqual(
        self, bookmarks: list[NetscapeBookmark], html_tags: list[BookmarkHtmlTag]
    ):
        self.assertEqual(len(bookmarks), len(html_tags))
        for bookmark in bookmarks:
            html_tag = html_tags[bookmarks.index(bookmark)]
            self.assertEqual(bookmark.href, html_tag.href)
            self.assertEqual(bookmark.title, html_tag.title)
            self.assertEqual(bookmark.date_added, html_tag.add_date)
            self.assertEqual(bookmark.date_modified, html_tag.last_modified)
            self.assertEqual(bookmark.description, html_tag.description)
            self.assertEqual(bookmark.tag_names, parse_tag_string(html_tag.tags))
            self.assertEqual(bookmark.to_read, html_tag.to_read)
            self.assertEqual(bookmark.private, html_tag.private)

    def test_parse_bookmarks(self):
        html_tags = [
            BookmarkHtmlTag(
                href="https://example.com",
                title="Example title",
                description="Example description",
                add_date="1",
                last_modified="11",
                tags="example-tag",
            ),
            BookmarkHtmlTag(
                href="https://example.com/foo",
                title="Foo title",
                description="",
                add_date="2",
                last_modified="22",
                tags="",
            ),
            BookmarkHtmlTag(
                href="https://example.com/bar",
                title="Bar title",
                description="Bar description",
                add_date="3",
                last_modified="33",
                tags="bar-tag, other-tag",
            ),
            BookmarkHtmlTag(
                href="https://example.com/baz",
                title="Baz title",
                description="Baz description",
                add_date="4",
                to_read=True,
            ),
        ]
        html = self.render_html(html_tags)
        bookmarks = parse(html)

        self.assertTagsEqual(bookmarks, html_tags)

    def test_no_bookmarks(self):
        html = self.render_html()
        bookmarks = parse(html)

        self.assertEqual(bookmarks, [])

    def test_reset_properties_after_adding_bookmark(self):
        html_tags = [
            BookmarkHtmlTag(
                href="https://example.com",
                title="Example title",
                description="Example description",
                add_date="1",
                last_modified="1",
                tags="example-tag",
            ),
            BookmarkHtmlTag(
                href="",
                title="",
                description="",
                add_date="",
                last_modified="",
                tags="",
            ),
        ]
        html = self.render_html(html_tags)
        bookmarks = parse(html)

        self.assertTagsEqual(bookmarks, html_tags)

    def test_empty_title(self):
        html_tags = [
            BookmarkHtmlTag(
                href="https://example.com",
                title="",
                description="Example description",
                add_date="1",
                tags="example-tag",
            ),
        ]
        html = self.render_html(
            tags_html="""
        <DT><A HREF="https://example.com" ADD_DATE="1" TAGS="example-tag"></A>
        <DD>Example description
        """
        )
        bookmarks = parse(html)

        self.assertTagsEqual(bookmarks, html_tags)

    def test_with_closing_description_tag(self):
        html_tags = [
            BookmarkHtmlTag(
                href="https://example.com",
                title="Example title",
                description="Example description",
                add_date="1",
                tags="example-tag",
            ),
            BookmarkHtmlTag(
                href="https://foo.com",
                title="Foo title",
                description="",
                add_date="2",
                tags="",
            ),
        ]
        html = self.render_html(
            tags_html="""
        <DT><A HREF="https://example.com" ADD_DATE="1" TAGS="example-tag">Example title</A>
        <DD>Example description</DD>
        <DT><A HREF="https://foo.com" ADD_DATE="2">Foo title</A>
        <DD></DD>
        """
        )
        bookmarks = parse(html)

        self.assertTagsEqual(bookmarks, html_tags)

    def test_description_tag_before_anchor_tag(self):
        html_tags = [
            BookmarkHtmlTag(
                href="https://example.com",
                title="Example title",
                description="Example description",
                add_date="1",
                tags="example-tag",
            ),
            BookmarkHtmlTag(
                href="https://foo.com",
                title="Foo title",
                description="",
                add_date="2",
                tags="",
            ),
        ]
        html = self.render_html(
            tags_html="""
        <DT><DD>Example description</DD>
        <A HREF="https://example.com" ADD_DATE="1" TAGS="example-tag">Example title</A>
        <DT><DD></DD>
        <A HREF="https://foo.com" ADD_DATE="2">Foo title</A>
        """
        )
        bookmarks = parse(html)

        self.assertTagsEqual(bookmarks, html_tags)

    def test_with_folders(self):
        html_tags = [
            BookmarkHtmlTag(
                href="https://example.com",
                title="Example title",
                description="Example description",
                add_date="1",
                tags="example-tag",
            ),
            BookmarkHtmlTag(
                href="https://foo.com",
                title="Foo title",
                description="",
                add_date="2",
                tags="",
            ),
        ]
        html = self.render_html(
            tags_html="""
        <DL><p>
            <DT><H3>Folder 1</H3>
            <DL><p>
                <DT><A HREF="https://example.com" ADD_DATE="1" TAGS="example-tag">Example title</A>
                <DD>Example description
            </DL><p>
            <DT><H3>Folder 2</H3>
            <DL><p>
                <DT><A HREF="https://foo.com" ADD_DATE="2">Foo title</A>
            </DL><p>
        </DL><p>
        """
        )
        bookmarks = parse(html)

        self.assertTagsEqual(bookmarks, html_tags)

    def test_private_flag(self):
        # is private by default
        html = self.render_html(
            tags_html="""
        <DT><A HREF="https://example.com" ADD_DATE="1">Example title</A>
        <DD>Example description</DD>
        """
        )
        bookmarks = parse(html)
        self.assertEqual(bookmarks[0].private, True)

        # explicitly marked as private
        html = self.render_html(
            tags_html="""
        <DT><A HREF="https://example.com" ADD_DATE="1" PRIVATE="1">Example title</A>
        <DD>Example description</DD>
        """
        )
        bookmarks = parse(html)
        self.assertEqual(bookmarks[0].private, True)

        # explicitly marked as public
        html = self.render_html(
            tags_html="""
        <DT><A HREF="https://example.com" ADD_DATE="1" PRIVATE="0">Example title</A>
        <DD>Example description</DD>
        """
        )
        bookmarks = parse(html)
        self.assertEqual(bookmarks[0].private, False)

    def test_notes(self):
        # no description, no notes
        html = self.render_html(
            tags_html="""
        <DT><A HREF="https://example.com" ADD_DATE="1">Example title</A>
        """
        )
        bookmarks = parse(html)
        self.assertEqual(bookmarks[0].description, "")
        self.assertEqual(bookmarks[0].notes, "")

        # description, no notes
        html = self.render_html(
            tags_html="""
        <DT><A HREF="https://example.com" ADD_DATE="1">Example title</A>
        <DD>Example description
        """
        )
        bookmarks = parse(html)
        self.assertEqual(bookmarks[0].description, "Example description")
        self.assertEqual(bookmarks[0].notes, "")

        # description, notes
        html = self.render_html(
            tags_html="""
        <DT><A HREF="https://example.com" ADD_DATE="1">Example title</A>
        <DD>Example description[linkding-notes]Example notes[/linkding-notes]
        """
        )
        bookmarks = parse(html)
        self.assertEqual(bookmarks[0].description, "Example description")
        self.assertEqual(bookmarks[0].notes, "Example notes")

        # description, notes without closing tag
        html = self.render_html(
            tags_html="""
        <DT><A HREF="https://example.com" ADD_DATE="1">Example title</A>
        <DD>Example description[linkding-notes]Example notes
        """
        )
        bookmarks = parse(html)
        self.assertEqual(bookmarks[0].description, "Example description")
        self.assertEqual(bookmarks[0].notes, "Example notes")

        # no description, notes
        html = self.render_html(
            tags_html="""
        <DT><A HREF="https://example.com" ADD_DATE="1">Example title</A>
        <DD>[linkding-notes]Example notes[/linkding-notes]
        """
        )
        bookmarks = parse(html)
        self.assertEqual(bookmarks[0].description, "")
        self.assertEqual(bookmarks[0].notes, "Example notes")

        # notes reset between bookmarks
        html = self.render_html(
            tags_html="""
        <DT><A HREF="https://example.com/1" ADD_DATE="1">Example title</A>
        <DD>[linkding-notes]Example notes[/linkding-notes]
        <DT><A HREF="https://example.com/2" ADD_DATE="1">Example title</A>
        <DD>Example description
        """
        )
        bookmarks = parse(html)
        self.assertEqual(bookmarks[0].description, "")
        self.assertEqual(bookmarks[0].notes, "Example notes")
        self.assertEqual(bookmarks[1].description, "Example description")
        self.assertEqual(bookmarks[1].notes, "")

    def test_unescape_content(self):
        html = self.render_html(
            tags_html="""
        <DT><A HREF="https://example.com" ADD_DATE="1">&lt;style&gt;: The Style Information element</A>
        <DD>The &lt;style&gt; HTML element contains style information for a document, or part of a document.[linkding-notes]Interesting notes about the &lt;style&gt; HTML element.[/linkding-notes]
        """
        )
        bookmarks = parse(html)
        self.assertEqual(bookmarks[0].title, "<style>: The Style Information element")
        self.assertEqual(
            bookmarks[0].description,
            "The <style> HTML element contains style information for a document, or part of a document.",
        )
        self.assertEqual(
            bookmarks[0].notes, "Interesting notes about the <style> HTML element."
        )

    def test_unescape_href_attribute(self):
        html = self.render_html(
            tags_html="""
        <DT><A HREF="https://example.com&center=123" ADD_DATE="1">Imported bookmark</A>
        <DD>Imported bookmark description
        """
        )

        bookmarks = parse(html)
        self.assertEqual(bookmarks[0].href, "https://example.com&center=123")


================================================
FILE: bookmarks/tests/test_password_change_view.py
================================================
from django.contrib.auth.models import User
from django.test import TestCase
from django.urls import reverse

from bookmarks.tests.helpers import BookmarkFactoryMixin


class PasswordChangeViewTestCase(TestCase, BookmarkFactoryMixin):
    def setUp(self) -> None:
        self.user = User.objects.create_user(
            "testuser", "test@example.com", "initial_password"
        )
        self.client.force_login(self.user)

    def test_change_password(self):
        form_data = {
            "old_password": "initial_password",
            "new_password1": "new_password",
            "new_password2": "new_password",
        }

        response = self.client.post(reverse("change_password"), form_data)

        self.assertRedirects(response, reverse("password_change_done"))

    def test_change_password_done(self):
        form_data = {
            "old_password": "initial_password",
            "new_password1": "new_password",
            "new_password2": "new_password",
        }

        response = self.client.post(reverse("change_password"), form_data, follow=True)

        self.assertContains(response, "Your password was changed successfully")

    def test_should_return_error_for_invalid_old_password(self):
        form_data = {
            "old_password": "wrong_password",
            "new_password1": "new_password",
            "new_password2": "new_password",
        }

        response = self.client.post(reverse("change_password"), form_data)

        self.assertEqual(response.status_code, 422)
        self.assertIn("old_password", response.context_data["form"].errors)

    def test_should_return_error_for_mismatching_new_password(self):
        form_data = {
            "old_password": "initial_password",
            "new_password1": "new_password",
            "new_password2": "wrong_password",
        }

        response = self.client.post(reverse("change_password"), form_data)

        self.assertEqual(response.status_code, 422)
        self.assertIn("new_password2", response.context_data["form"].errors)


================================================
FILE: bookmarks/tests/test_preview_image_loader.py
================================================
import io
import os
import tempfile
from pathlib import Path
from unittest import mock

from django.conf import settings
from django.test import TestCase

from bookmarks.services import preview_image_loader

mock_image_data = b"mock_image"


class MockStreamingResponse:
    def __init__(
        self,
        url,
        data=mock_image_data,
        content_type="image/png",
        content_length=None,
        status_code=200,
    ):
        self.url = url
        self.chunks = [data]
        self.status_code = status_code
        if not content_length:
            content_length = len(data)
        self.headers = {"Content-Type": content_type, "Content-Length": content_length}

    def iter_content(self, **kwargs):
        return self.chunks

    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        pass


class PreviewImageLoaderTestCase(TestCase):
    def setUp(self) -> None:
        self.temp_folder = tempfile.TemporaryDirectory()
        self.settings_override = self.settings(LD_PREVIEW_FOLDER=self.temp_folder.name)
        self.settings_override.enable()
        self.mock_load_website_metadata_patcher = mock.patch(
            "bookmarks.services.website_loader.load_website_metadata"
        )
        self.mock_load_website_metadata = (
            self.mock_load_website_metadata_patcher.start()
        )
        self.mock_load_website_metadata.return_value = mock.Mock(
            preview_image="https://example.com/image.png"
        )

    def tearDown(self) -> None:
        self.temp_folder.cleanup()
        self.settings_override.disable()
        self.mock_load_website_metadata_patcher.stop()

    def create_mock_response(
        self,
        url="https://example.com/image.png",
        icon_data=mock_image_data,
        content_type="image/png",
        content_length=None,
        status_code=200,
    ):
        if not content_length:
            content_length = len(icon_data)
        mock_response = mock.Mock()
        mock_response.raw = io.BytesIO(icon_data)
        return MockStreamingResponse(
            url, icon_data, content_type, content_length, status_code
        )

    def get_image_path(self, filename):
        return Path(os.path.join(settings.LD_PREVIEW_FOLDER, filename))

    def assertImageExists(self, filename, data):
        self.assertTrue(self.get_image_path(filename).exists())
        self.assertEqual(self.get_image_path(filename).read_bytes(), data)

    def assertNoImageExists(self):
        self.assertFalse(os.listdir(settings.LD_PREVIEW_FOLDER))

    def test_load_preview_image(self):
        with mock.patch("requests.get") as mock_get:
            mock_get.return_value = self.create_mock_response()

            file = preview_image_loader.load_preview_image("https://example.com")

            self.assertIsNotNone(file)
            self.assertImageExists(file, mock_image_data)

    def test_load_preview_image_returns_none_if_no_preview_image_detected(self):
        with mock.patch("requests.get") as mock_get:
            mock_get.return_value = self.create_mock_response()
            self.mock_load_website_metadata.return_value = mock.Mock(preview_image=None)

            file = preview_image_loader.load_preview_image("https://example.com")

            self.assertIsNone(file)
            self.assertNoImageExists()

    def test_load_preview_image_returns_none_for_invalid_status_code(self):
        invalid_status_codes = [199, 300, 400, 500]

        for status_code in invalid_status_codes:
            with mock.patch("requests.get") as mock_get:
                mock_get.return_value = self.create_mock_response(
                    status_code=status_code
                )

                file = preview_image_loader.load_preview_image("https://example.com")

                self.assertIsNone(file)
                self.assertNoImageExists()

    def test_load_preview_image_returns_none_if_content_length_exceeds_limit(self):
        # exceeds max size
        with mock.patch("requests.get") as mock_get:
            mock_get.return_value = self.create_mock_response(
                content_length=settings.LD_PREVIEW_MAX_SIZE + 1
            )

            file = preview_image_loader.load_preview_image("https://example.com")

            self.assertIsNone(file)
            self.assertNoImageExists()

        # equals max size
        with mock.patch("requests.get") as mock_get:
            mock_get.return_value = self.create_mock_response(
                content_length=settings.LD_PREVIEW_MAX_SIZE
            )

            file = preview_image_loader.load_preview_image("https://example.com")

            self.assertIsNotNone(file)
            self.assertImageExists(file, mock_image_data)

    def test_load_preview_image_returns_none_for_invalid_content_type(self):
        invalid_content_types = ["text/html", "application/json"]

        for content_type in invalid_content_types:
            with mock.patch("requests.get") as mock_get:
                mock_get.return_value = self.create_mock_response(
                    content_type=content_type
                )

                file = preview_image_loader.load_preview_image("https://example.com")

                self.assertIsNone(file)
                self.assertNoImageExists()

        valid_content_types = ["image/png", "image/jpeg", "image/gif"]

        for content_type in valid_content_types:
            with mock.patch("requests.get") as mock_get:
                mock_get.return_value = self.create_mock_response(
                    content_type=content_type
                )

                file = preview_image_loader.load_preview_image("https://example.com")

                self.assertIsNotNone(file)
                self.assertImageExists(file, mock_image_data)

    def test_load_preview_image_returns_none_if_download_exceeds_content_length(self):
        with mock.patch("requests.get") as mock_get:
            mock_get.return_value = self.create_mock_response(content_length=1)

            file = preview_image_loader.load_preview_image("https://example.com")

            self.assertIsNone(file)
            self.assertNoImageExists()

    def test_load_preview_image_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_PREVIEW_FOLDER)
            folder.rmdir()

            self.assertFalse(folder.exists())

            preview_image_loader.load_preview_image("https://example.com")

            self.assertTrue(folder.exists())

    def test_guess_file_extension(self):
        with mock.patch("requests.get") as mock_get:
            mock_get.return_value = self.create_mock_response(content_type="image/png")

            file = preview_image_loader.load_preview_image("https://example.com")

            self.assertImageExists(file, mock_image_data)
            self.assertEqual("png", file.split(".")[-1])

        with mock.patch("requests.get") as mock_get:
            mock_get.return_value = self.create_mock_response(content_type="image/jpeg")

            file = preview_image_loader.load_preview_image("https://example.com")

            self.assertImageExists(file, mock_image_data)
            self.assertEqual("jpg", file.split(".")[-1])


================================================
FILE: bookmarks/tests/test_queries.py
================================================
import datetime
import operator

from django.db.models import QuerySet
from django.test import TestCase
from django.utils import timezone

from bookmarks import queries
from bookmarks.models import BookmarkBundle, BookmarkSearch, UserProfile
from bookmarks.tests.helpers import BookmarkFactoryMixin, random_sentence
from bookmarks.utils import unique


class QueriesBasicTestCase(TestCase, BookmarkFactoryMixin):
    def setUp(self):
        self.profile = self.get_or_create_test_user().profile

    def setup_bookmark_search_data(self) -> None:
        tag1 = self.setup_tag(name="tag1")
        tag2 = self.setup_tag(name="tag2")
        self.setup_tag(name="unused_tag1")

        self.other_bookmarks = [
            self.setup_bookmark(),
            self.setup_bookmark(),
            self.setup_bookmark(),
        ]
        self.term1_bookmarks = [
            self.setup_bookmark(url="http://example.com/term1"),
            self.setup_bookmark(title=random_sentence(including_word="term1")),
            self.setup_bookmark(title=random_sentence(including_word="TERM1")),
            self.setup_bookmark(description=random_sentence(including_word="term1")),
            self.setup_bookmark(description=random_sentence(including_word="TERM1")),
            self.setup_bookmark(notes=random_sentence(including_word="term1")),
            self.setup_bookmark(notes=random_sentence(including_word="TERM1")),
        ]
        self.term1_term2_bookmarks = [
            self.setup_bookmark(url="http://example.com/term1/term2"),
            self.setup_bookmark(
                title=random_sentence(including_word="term1"),
                description=random_sentence(including_word="term2"),
            ),
            self.setup_bookmark(
                description=random_sentence(including_word="term1"),
                title=random_sentence(including_word="term2"),
            ),
        ]
        self.tag1_bookmarks = [
            self.setup_bookmark(tags=[tag1]),
            self.setup_bookmark(title=random_sentence(), tags=[tag1]),
            self.setup_bookmark(description=random_sentence(), tags=[tag1]),
        ]
        self.tag1_as_term_bookmarks = [
            self.setup_bookmark(url="http://example.com/tag1"),
            self.setup_bookmark(title=random_sentence(including_word="tag1")),
            self.setup_bookmark(description=random_sentence(including_word="tag1")),
        ]
        self.term1_tag1_bookmarks = [
            self.setup_bookmark(url="http://example.com/term1", tags=[tag1]),
            self.setup_bookmark(
                title=random_sentence(including_word="term1"), tags=[tag1]
            ),
            self.setup_bookmark(
                description=random_sentence(including_word="term1"), tags=[tag1]
            ),
        ]
        self.tag2_bookmarks = [
            self.setup_bookmark(tags=[tag2]),
        ]
        self.tag1_tag2_bookmarks = [
            self.setup_bookmark(tags=[tag1, tag2]),
        ]

    def setup_tag_search_data(self):
        tag1 = self.setup_tag(name="tag1")
        tag2 = self.setup_tag(name="tag2")
        self.setup_tag(name="unused_tag1")

        self.other_bookmarks = [
            self.setup_bookmark(tags=[self.setup_tag()]),
            self.setup_bookmark(tags=[self.setup_tag()]),
            self.setup_bookmark(tags=[self.setup_tag()]),
        ]
        self.term1_bookmarks = [
            self.setup_bookmark(
                url="http://example.com/term1", tags=[self.setup_tag()]
            ),
            self.setup_bookmark(
                title=random_sentence(including_word="term1"), tags=[self.setup_tag()]
            ),
            self.setup_bookmark(
                title=random_sentence(including_word="TERM1"), tags=[self.setup_tag()]
            ),
            self.setup_bookmark(
                description=random_sentence(including_word="term1"),
                tags=[self.setup_tag()],
            ),
            self.setup_bookmark(
                description=random_sentence(including_word="TERM1"),
                tags=[self.setup_tag()],
            ),
            self.setup_bookmark(
                notes=random_sentence(including_word="term1"), tags=[self.setup_tag()]
            ),
            self.setup_bookmark(
                notes=random_sentence(including_word="TERM1"), tags=[self.setup_tag()]
            ),
        ]
        self.term1_term2_bookmarks = [
            self.setup_bookmark(
                url="http://example.com/term1/term2", tags=[self.setup_tag()]
            ),
            self.setup_bookmark(
                title=random_sentence(including_word="term1"),
                description=random_sentence(including_word="term2"),
                tags=[self.setup_tag()],
            ),
            self.setup_bookmark(
                description=random_sentence(including_word="term1"),
                title=random_sentence(including_word="term2"),
                tags=[self.setup_tag()],
            ),
        ]
        self.tag1_bookmarks = [
            self.setup_bookmark(tags=[tag1, self.setup_tag()]),
            self.setup_bookmark(title=random_sentence(), tags=[tag1, self.setup_tag()]),
            self.setup_bookmark(
                description=random_sentence(), tags=[tag1, self.setup_tag()]
            ),
        ]
        self.tag1_as_term_bookmarks = [
            self.setup_bookmark(url="http://example.com/tag1"),
            self.setup_bookmark(title=random_sentence(including_word="tag1")),
            self.setup_bookmark(description=random_sentence(including_word="tag1")),
        ]
        self.term1_tag1_bookmarks = [
            self.setup_bookmark(
                url="http://example.com/term1", tags=[tag1, self.setup_tag()]
            ),
            self.setup_bookmark(
                title=random_sentence(including_word="term1"),
                tags=[tag1, self.setup_tag()],
            ),
            self.setup_bookmark(
                description=random_sentence(including_word="term1"),
                tags=[tag1, self.setup_tag()],
            ),
        ]
        self.tag2_bookmarks = [
            self.setup_bookmark(tags=[tag2, self.setup_tag()]),
        ]
        self.tag1_tag2_bookmarks = [
            self.setup_bookmark(tags=[tag1, tag2, self.setup_tag()]),
        ]

    def assertQueryResult(self, query: QuerySet, item_lists: list[list]):
        expected_items = []
        for item_list in item_lists:
            expected_items = expected_items + item_list

        expected_items = unique(expected_items, operator.attrgetter("id"))

        self.assertCountEqual(list(query), expected_items)

    def test_query_bookmarks_should_return_all_for_empty_query(self):
        self.setup_bookmark_search_data()

        query = queries.query_bookmarks(self.user, self.profile, BookmarkSearch(q=""))
        self.assertQueryResult(
            query,
            [
                self.other_bookmarks,
                self.term1_bookmarks,
                self.term1_term2_bookmarks,
                self.tag1_bookmarks,
                self.tag1_as_term_bookmarks,
                self.term1_tag1_bookmarks,
                self.tag2_bookmarks,
                self.tag1_tag2_bookmarks,
            ],
        )

    def test_query_bookmarks_should_search_single_term(self):
        self.setup_bookmark_search_data()

        query = queries.query_bookmarks(
            self.user, self.profile, BookmarkSearch(q="term1")
        )
        self.assertQueryResult(
            query,
            [
                self.term1_bookmarks,
                self.term1_term2_bookmarks,
                self.term1_tag1_bookmarks,
            ],
        )

    def test_query_bookmarks_should_search_multiple_terms(self):
        self.setup_bookmark_search_data()

        query = queries.query_bookmarks(
            self.user, self.profile, BookmarkSearch(q="term2 term1")
        )

        self.assertQueryResult(query, [self.term1_term2_bookmarks])

    def test_query_bookmarks_should_search_single_tag(self):
        self.setup_bookmark_search_data()

        query = queries.query_bookmarks(
            self.user, self.profile, BookmarkSearch(q="#tag1")
        )

        self.assertQueryResult(
            query,
            [self.tag1_bookmarks, self.tag1_tag2_bookmarks, self.term1_tag1_bookmarks],
        )

    def test_query_bookmarks_should_search_multiple_tags(self):
        self.setup_bookmark_search_data()

        query = queries.query_bookmarks(
            self.user, self.profile, BookmarkSearch(q="#tag1 #tag2")
        )

        self.assertQueryResult(query, [self.tag1_tag2_bookmarks])

    def test_query_bookmarks_should_search_multiple_tags_ignoring_casing(self):
        self.setup_bookmark_search_data()

        query = queries.query_bookmarks(
            self.user, self.profile, BookmarkSearch(q="#Tag1 #TAG2")
        )

        self.assertQueryResult(query, [self.tag1_tag2_bookmarks])

    def test_query_bookmarks_should_search_terms_and_tags_combined(self):
        self.setup_bookmark_search_data()

        query = queries.query_bookmarks(
            self.user, self.profile, BookmarkSearch(q="term1 #tag1")
        )

        self.assertQueryResult(query, [self.term1_tag1_bookmarks])

    def test_query_bookmarks_in_strict_mode_should_not_search_tags_as_terms(self):
        self.setup_bookmark_search_data()

        self.profile.tag_search = UserProfile.TAG_SEARCH_STRICT
        self.profile.save()

        query = queries.query_bookmarks(
            self.user, self.profile, BookmarkSearch(q="tag1")
        )
        self.assertQueryResult(query, [self.tag1_as_term_bookmarks])

    def test_query_bookmarks_in_lax_mode_should_search_tags_as_terms(self):
        self.setup_bookmark_search_data()

        self.profile.tag_search = UserProfile.TAG_SEARCH_LAX
        self.profile.save()

        query = queries.query_bookmarks(
            self.user, self.profile, BookmarkSearch(q="tag1")
        )
        self.assertQueryResult(
            query,
            [
                self.tag1_bookmarks,
                self.tag1_as_term_bookmarks,
                self.tag1_tag2_bookmarks,
                self.term1_tag1_bookmarks,
            ],
        )

        query = queries.query_bookmarks(
            self.user, self.profile, BookmarkSearch(q="tag1 term1")
        )
        self.assertQueryResult(
            query,
            [
                self.term1_tag1_bookmarks,
            ],
        )

        query = queries.query_bookmarks(
            self.user, self.profile, BookmarkSearch(q="tag1 tag2")
        )
        self.assertQueryResult(
            query,
            [
                self.tag1_tag2_bookmarks,
            ],
        )

        query = queries.query_bookmarks(
            self.user, self.profile, BookmarkSearch(q="tag1 #tag2")
        )
        self.assertQueryResult(
            query,
            [
                self.tag1_tag2_bookmarks,
            ],
        )

    def test_query_bookmarks_should_return_no_matches(self):
        self.setup_bookmark_search_data()

        query = queries.query_bookmarks(
            self.user, self.profile, BookmarkSearch(q="term3")
        )
        self.assertQueryResult(query, [])

        query = queries.query_bookmarks(
            self.user, self.profile, BookmarkSearch(q="term1 term3")
        )
        self.assertQueryResult(query, [])

        query = queries.query_bookmarks(
            self.user, self.profile, BookmarkSearch(q="term1 #tag2")
        )
        self.assertQueryResult(query, [])

        query = queries.query_bookmarks(
            self.user, self.profile, BookmarkSearch(q="#tag3")
        )
        self.assertQueryResult(query, [])

        # Unused tag
        query = queries.query_bookmarks(
            self.user, self.profile, BookmarkSearch(q="#unused_tag1")
        )
        self.assertQueryResult(query, [])

        # Unused tag combined with tag that is used
        query = queries.query_bookmarks(
            self.user, self.profile, BookmarkSearch(q="#tag1 #unused_tag1")
        )
        self.assertQueryResult(query, [])

        # Unused tag combined with term that is used
        query = queries.query_bookmarks(
            self.user, self.profile, BookmarkSearch(q="term1 #unused_tag1")
        )
        self.assertQueryResult(query, [])

    def test_query_bookmarks_should_not_return_archived_bookmarks(self):
        bookmark1 = self.setup_bookmark()
        bookmark2 = self.setup_bookmark()
        self.setup_bookmark(is_archived=True)
        self.setup_bookmark(is_archived=True)
        self.setup_bookmark(is_archived=True)

        query = queries.query_bookmarks(self.user, self.profile, BookmarkSearch(q=""))

        self.assertQueryResult(query, [[bookmark1, bookmark2]])

    def test_query_archived_bookmarks_should_not_return_unarchived_bookmarks(self):
        bookmark1 = self.setup_bookmark(is_archived=True)
        bookmark2 = self.setup_bookmark(is_archived=True)
        self.setup_bookmark()
        self.setup_bookmark()
        self.setup_bookmark()

        query = queries.query_archived_bookmarks(
            self.user, self.profile, BookmarkSearch(q="")
        )

        self.assertQueryResult(query, [[bookmark1, bookmark2]])

    def test_query_bookmarks_should_only_return_user_owned_bookmarks(self):
        other_user = self.setup_user()
        owned_bookmarks = [
            self.setup_bookmark(),
            self.setup_bookmark(),
            self.setup_bookmark(),
        ]
        self.setup_bookmark(user=other_user)
        self.setup_bookmark(user=other_user)
        self.setup_bookmark(user=other_user)

        query = queries.query_bookmarks(self.user, self.profile, BookmarkSearch(q=""))

        self.assertQueryResult(query, [owned_bookmarks])

    def test_query_archived_bookmarks_should_only_return_user_owned_bookmarks(self):
        other_user = self.setup_user()
        owned_bookmarks = [
            self.setup_bookmark(is_archived=True),
            self.setup_bookmark(is_archived=True),
            self.setup_bookmark(is_archived=True),
        ]
        self.setup_bookmark(is_archived=True, user=other_user)
        self.setup_bookmark(is_archived=True, user=other_user)
        self.setup_bookmark(is_archived=True, user=other_user)

        query = queries.query_archived_bookmarks(
            self.user, self.profile, BookmarkSearch(q="")
        )

        self.assertQueryResult(query, [owned_bookmarks])

    def test_query_bookmarks_untagged_should_return_untagged_bookmarks_only(self):
        tag = self.setup_tag()
        untagged_bookmark = self.setup_bookmark()
        self.setup_bookmark(tags=[tag])
        self.setup_bookmark(tags=[tag])

        query = queries.query_bookmarks(
            self.user, self.profile, BookmarkSearch(q="!untagged")
        )
        self.assertCountEqual(list(query), [untagged_bookmark])

    def test_query_bookmarks_untagged_should_be_combinable_with_search_terms(self):
        tag = self.setup_tag()
        untagged_bookmark = self.setup_bookmark(title="term1")
        self.setup_bookmark(title="term2")
        self.setup_bookmark(tags=[tag])

        query = queries.query_bookmarks(
            self.user, self.profile, BookmarkSearch(q="!untagged term1")
        )
        self.assertCountEqual(list(query), [untagged_bookmark])

    def test_query_bookmarks_untagged_should_not_be_combinable_with_tags(self):
        tag = self.setup_tag()
        self.setup_bookmark()
        self.setup_bookmark(tags=[tag])
        self.setup_bookmark(tags=[tag])

        query = queries.query_bookmarks(
            self.user, self.profile, BookmarkSearch(q=f"!untagged #{tag.name}")
        )
        self.assertCountEqual(list(query), [])

    def test_query_archived_bookmarks_untagged_should_return_untagged_bookmarks_only(
        self,
    ):
        tag = self.setup_tag()
        untagged_bookmark = self.setup_bookmark(is_archived=True)
        self.setup_bookmark(is_archived=True, tags=[tag])
        self.setup_bookmark(is_archived=True, tags=[tag])

        query = queries.query_archived_bookmarks(
            self.user, self.profile, BookmarkSearch(q="!untagged")
        )
        self.assertCountEqual(list(query), [untagged_bookmark])

    def test_query_archived_bookmarks_untagged_should_be_combinable_with_search_terms(
        self,
    ):
        tag = self.setup_tag()
        untagged_bookmark = self.setup_bookmark(is_archived=True, title="term1")
        self.setup_bookmark(is_archived=True, title="term2")
        self.setup_bookmark(is_archived=True, tags=[tag])

        query = queries.query_archived_bookmarks(
            self.user, self.profile, BookmarkSearch(q="!untagged term1")
        )
        self.assertCountEqual(list(query), [untagged_bookmark])

    def test_query_archived_bookmarks_untagged_should_not_be_combinable_with_tags(self):
        tag = self.setup_tag()
        self.setup_bookmark(is_archived=True)
        self.setup_bookmark(is_archived=True, tags=[tag])
        self.setup_bookmark(is_archived=True, tags=[tag])

        query = queries.query_archived_bookmarks(
            self.user, self.profile, BookmarkSearch(q=f"!untagged #{tag.name}")
        )
        self.assertCountEqual(list(query), [])

    def test_query_bookmarks_unread_should_return_unread_bookmarks_only(self):
        unread_bookmarks = self.setup_numbered_bookmarks(5, unread=True)
        read_bookmarks = self.setup_numbered_bookmarks(5, unread=False)

        # Legacy query filter
        query = queries.query_bookmarks(
            self.user, self.profile, BookmarkSearch(q="!unread")
        )
        self.assertCountEqual(list(query), unread_bookmarks)

        # Bookmark search filter - off
        query = queries.query_bookmarks(
            self.user,
            self.profile,
            BookmarkSearch(unread=BookmarkSearch.FILTER_UNREAD_OFF),
        )
        self.assertCountEqual(list(query), read_bookmarks + unread_bookmarks)

        # Bookmark search filter - yes
        query = queries.query_bookmarks(
            self.user,
            self.profile,
            BookmarkSearch(unread=BookmarkSearch.FILTER_UNREAD_YES),
        )
        self.assertCountEqual(list(query), unread_bookmarks)

        # Bookmark search filter - no
        query = queries.query_bookmarks(
            self.user,
            self.profile,
            BookmarkSearch(unread=BookmarkSearch.FILTER_UNREAD_NO),
        )
        self.assertCountEqual(list(query), read_bookmarks)

    def test_query_archived_bookmarks_unread_should_return_unread_bookmarks_only(self):
        unread_bookmarks = self.setup_numbered_bookmarks(5, unread=True, archived=True)
        read_bookmarks = self.setup_numbered_bookmarks(5, unread=False, archived=True)

        # Legacy query filter
        query = queries.query_archived_bookmarks(
            self.user, self.profile, BookmarkSearch(q="!unread")
        )
        self.assertCountEqual(list(query), unread_bookmarks)

        # Bookmark search filter - off
        query = queries.query_archived_bookmarks(
            self.user,
            self.profile,
            BookmarkSearch(unread=BookmarkSearch.FILTER_UNREAD_OFF),
        )
        self.assertCountEqual(list(query), read_bookmarks + unread_bookmarks)

        # Bookmark search filter - yes
        query = queries.query_archived_bookmarks(
            self.user,
            self.profile,
            BookmarkSearch(unread=BookmarkSearch.FILTER_UNREAD_YES),
        )
        self.assertCountEqual(list(query), unread_bookmarks)

        # Bookmark search filter - no
        query = queries.query_archived_bookmarks(
            self.user,
            self.profile,
            BookmarkSearch(unread=BookmarkSearch.FILTER_UNREAD_NO),
        )
        self.assertCountEqual(list(query), read_bookmarks)

    def test_query_bookmarks_filter_shared(self):
        unshared_bookmarks = self.setup_numbered_bookmarks(5)
        shared_bookmarks = self.setup_numbered_bookmarks(5, shared=True)

        # Filter is off
        search = BookmarkSearch(shared=BookmarkSearch.FILTER_SHARED_OFF)
        query = queries.query_bookmarks(self.user, self.profile, search)
        self.assertCountEqual(list(query), unshared_bookmarks + shared_bookmarks)

        # Filter for shared
        search = BookmarkSearch(shared=BookmarkSearch.FILTER_SHARED_SHARED)
        query = queries.query_bookmarks(self.user, self.profile, search)
        self.assertCountEqual(list(query), shared_bookmarks)

        # Filter for unshared
        search = BookmarkSearch(shared=BookmarkSearch.FILTER_SHARED_UNSHARED)
        query = queries.query_bookmarks(self.user, self.profile, search)
        self.assertCountEqual(list(query), unshared_bookmarks)

    def test_query_bookmark_tags_should_return_all_tags_for_empty_query(self):
        self.setup_tag_search_data()

        query = queries.query_bookmark_tags(
            self.user, self.profile, BookmarkSearch(q="")
        )

        self.assertQueryResult(
            query,
            [
                self.get_tags_from_bookmarks(self.other_bookmarks),
                self.get_tags_from_bookmarks(self.term1_bookmarks),
                self.get_tags_from_bookmarks(self.term1_term2_bookmarks),
                self.get_tags_from_bookmarks(self.tag1_bookmarks),
                self.get_tags_from_bookmarks(self.term1_tag1_bookmarks),
                self.get_tags_from_bookmarks(self.tag2_bookmarks),
                self.get_tags_from_bookmarks(self.tag1_tag2_bookmarks),
            ],
        )

    def test_query_bookmark_tags_should_search_single_term(self):
        self.setup_tag_search_data()

        query = queries.query_bookmark_tags(
            self.user, self.profile, BookmarkSearch(q="term1")
        )

        self.assertQueryResult(
            query,
            [
                self.get_tags_from_bookmarks(self.term1_bookmarks),
                self.get_tags_from_bookmarks(self.term1_term2_bookmarks),
                self.get_tags_from_bookmarks(self.term1_tag1_bookmarks),
            ],
        )

    def test_query_bookmark_tags_should_search_multiple_terms(self):
        self.setup_tag_search_data()

        query = queries.query_bookmark_tags(
            self.user, self.profile, BookmarkSearch(q="term2 term1")
        )

        self.assertQueryResult(
            query,
            [
                self.get_tags_from_bookmarks(self.term1_term2_bookmarks),
            ],
        )

    def test_query_bookmark_tags_should_search_single_tag(self):
        self.setup_tag_search_data()

        query = queries.query_bookmark_tags(
            self.user, self.profile, BookmarkSearch(q="#tag1")
        )

        self.assertQueryResult(
            query,
            [
                self.get_tags_from_bookmarks(self.tag1_bookmarks),
                self.get_tags_from_bookmarks(self.term1_tag1_bookmarks),
                self.get_tags_from_bookmarks(self.tag1_tag2_bookmarks),
            ],
        )

    def test_query_bookmark_tags_should_search_multiple_tags(self):
        self.setup_tag_search_data()

        query = queries.query_bookmark_tags(
            self.user, self.profile, BookmarkSearch(q="#tag1 #tag2")
        )

        self.assertQueryResult(
            query,
            [
                self.get_tags_from_bookmarks(self.tag1_tag2_bookmarks),
            ],
        )

    def test_query_bookmark_tags_should_search_multiple_tags_ignoring_casing(self):
        self.setup_tag_search_data()

        query = queries.query_bookmark_tags(
            self.user, self.profile, BookmarkSearch(q="#Tag1 #TAG2")
        )

        self.assertQueryResult(
            query,
            [
                self.get_tags_from_bookmarks(self.tag1_tag2_bookmarks),
            ],
        )

    def test_query_bookmark_tags_should_search_term_and_tag_combined(self):
        self.setup_tag_search_data()

        query = queries.query_bookmark_tags(
            self.user, self.profile, BookmarkSearch(q="term1 #tag1")
        )

        self.assertQueryResult(
            query,
            [
                self.get_tags_from_bookmarks(self.term1_tag1_bookmarks),
            ],
        )

    def test_query_bookmark_tags_in_strict_mode_should_not_search_tags_as_terms(self):
        self.setup_tag_search_data()

        self.profile.tag_search = UserProfile.TAG_SEARCH_STRICT
        self.profile.save()

        query = queries.query_bookmark_tags(
            self.user, self.profile, BookmarkSearch(q="tag1")
        )
        self.assertQueryResult(
            query, self.get_tags_from_bookmarks(self.tag1_as_term_bookmarks)
        )

    def test_query_bookmark_tags_in_lax_mode_should_search_tags_as_terms(self):
        self.setup_tag_search_data()

        self.profile.tag_search = UserProfile.TAG_SEARCH_LAX
        self.profile.save()

        query = queries.query_bookmark_tags(
            self.user, self.profile, BookmarkSearch(q="tag1")
        )
        self.assertQueryResult(
            query,
            [
                self.get_tags_from_bookmarks(self.tag1_bookmarks),
                self.get_tags_from_bookmarks(self.tag1_as_term_bookmarks),
                self.get_tags_from_bookmarks(self.tag1_tag2_bookmarks),
                self.get_tags_from_bookmarks(self.term1_tag1_bookmarks),
            ],
        )

        query = queries.query_bookmark_tags(
            self.user, self.profile, BookmarkSearch(q="tag1 term1")
        )
        self.assertQueryResult(
            query,
            [
                self.get_tags_from_bookmarks(self.term1_tag1_bookmarks),
            ],
        )

        query = queries.query_bookmark_tags(
            self.user, self.profile, BookmarkSearch(q="tag1 tag2")
        )
        self.assertQueryResult(
            query,
            [
                self.get_tags_from_bookmarks(self.tag1_tag2_bookmarks),
            ],
        )

        query = queries.query_bookmark_tags(
            self.user, self.profile, BookmarkSearch(q="tag1 #tag2")
        )
        self.assertQueryResult(
            query,
            [
                self.get_tags_from_bookmarks(self.tag1_tag2_bookmarks),
            ],
        )

    def test_query_bookmark_tags_should_return_no_matches(self):
        self.setup_tag_search_data()

        query = queries.query_bookmark_tags(
            self.user, self.profile, BookmarkSearch(q="term3")
        )
        self.assertQueryResult(query, [])

        query = queries.query_bookmark_tags(
            self.user, self.profile, BookmarkSearch(q="term1 term3")
        )
        self.assertQueryResult(query, [])

        query = queries.query_bookmark_tags(
            self.user, self.profile, BookmarkSearch(q="term1 #tag2")
        )
        self.assertQueryResult(query, [])

        query = queries.query_bookmark_tags(
            self.user, self.profile, BookmarkSearch(q="#tag3")
        )
        self.assertQueryResult(query, [])

        # Unused tag
        query = queries.query_bookmark_tags(
            self.user, self.profile, BookmarkSearch(q="#unused_tag1")
        )
        self.assertQueryResult(query, [])

        # Unused tag combined with tag that is used
        query = queries.query_bookmark_tags(
            self.user, self.profile, BookmarkSearch(q="#tag1 #unused_tag1")
        )
        self.assertQueryResult(query, [])

        # Unused tag combined with term that is used
        query = queries.query_bookmark_tags(
            self.user, self.profile, BookmarkSearch(q="term1 #unused_tag1")
        )
        self.assertQueryResult(query, [])

    def test_query_bookmark_tags_should_return_tags_for_unarchived_bookmarks_only(self):
        tag1 = self.setup_tag()
        tag2 = self.setup_tag()
        self.setup_bookmark(tags=[tag1])
        self.setup_bookmark()
        self.setup_bookmark(is_archived=True, tags=[tag2])

        query = queries.query_bookmark_tags(
            self.user, self.profile, BookmarkSearch(q="")
        )

        self.assertQueryResult(query, [[tag1]])

    def test_query_bookmark_tags_should_return_distinct_tags(self):
        tag = self.setup_tag()
        self.setup_bookmark(tags=[tag])
        self.setup_bookmark(tags=[tag])
        self.setup_bookmark(tags=[tag])

        query = queries.query_bookmark_tags(
            self.user, self.profile, BookmarkSearch(q="")
        )

        self.assertQueryResult(query, [[tag]])

    def test_query_archived_bookmark_tags_should_return_tags_for_archived_bookmarks_only(
        self,
    ):
        tag1 = self.setup_tag()
        tag2 = self.setup_tag()
        self.setup_bookmark(tags=[tag1])
        self.setup_bookmark()
        self.setup_bookmark(is_archived=True, tags=[tag2])

        query = queries.query_archived_bookmark_tags(
            self.user, self.profile, BookmarkSearch(q="")
        )

        self.assertQueryResult(query, [[tag2]])

    def test_query_archived_bookmark_tags_should_return_distinct_tags(self):
        tag = self.setup_tag()
        self.setup_bookmark(is_archived=True, tags=[tag])
        self.setup_bookmark(is_archived=True, tags=[tag])
        self.setup_bookmark(is_archived=True, tags=[tag])

        query = queries.query_archived_bookmark_tags(
            self.user, self.profile, BookmarkSearch(q="")
        )

        self.assertQueryResult(query, [[tag]])

    def test_query_bookmark_tags_should_only_return_user_owned_tags(self):
        other_user = self.setup_user()
        owned_bookmarks = [
            self.setup_bookmark(tags=[self.setup_tag()]),
            self.setup_bookmark(tags=[self.setup_tag()]),
            self.setup_bookmark(tags=[self.setup_tag()]),
        ]
        self.setup_bookmark(user=other_user, tags=[self.setup_tag(user=other_user)])
        self.setup_bookmark(user=other_user, tags=[self.setup_tag(user=other_user)])
        self.setup_bookmark(user=other_user, tags=[self.setup_tag(user=other_user)])

        query = queries.query_bookmark_tags(
            self.user, self.profile, BookmarkSearch(q="")
        )

        self.assertQueryResult(query, [self.get_tags_from_bookmarks(owned_bookmarks)])

    def test_query_archived_bookmark_tags_should_only_return_user_owned_tags(self):
        other_user = self.setup_user()
        owned_bookmarks = [
            self.setup_bookmark(is_archived=True, tags=[self.setup_tag()]),
            self.setup_bookmark(is_archived=True, tags=[self.setup_tag()]),
            self.setup_bookmark(is_archived=True, tags=[self.setup_tag()]),
        ]
        self.setup_bookmark(
            is_archived=True, user=other_user, tags=[self.setup_tag(user=other_user)]
        )
        self.setup_bookmark(
            is_archived=True, user=other_user, tags=[self.setup_tag(user=other_user)]
        )
        self.setup_bookmark(
            is_archived=True, user=other_user, tags=[self.setup_tag(user=other_user)]
        )

        query = queries.query_archived_bookmark_tags(
            self.user, self.profile, BookmarkSearch(q="")
        )

        self.assertQueryResult(query, [self.get_tags_from_bookmarks(owned_bookmarks)])

    def test_query_bookmark_tags_untagged_should_never_return_any_tags(self):
        tag = self.setup_tag()
        self.setup_bookmark()
        self.setup_bookmark(title="term1")
        self.setup_bookmark(title="term1", tags=[tag])
        self.setup_bookmark(tags=[tag])

        query = queries.query_bookmark_tags(
            self.user, self.profile, BookmarkSearch(q="!untagged")
        )
        self.assertCountEqual(list(query), [])

        query = queries.query_bookmark_tags(
            self.user, self.profile, BookmarkSearch(q="!untagged term1")
        )
        self.assertCountEqual(list(query), [])

        query = queries.query_bookmark_tags(
            self.user, self.profile, BookmarkSearch(q=f"!untagged #{tag.name}")
        )
        self.assertCountEqual(list(query), [])

    def test_query_archived_bookmark_tags_untagged_should_never_return_any_tags(self):
        tag = self.setup_tag()
        self.setup_bookmark(is_archived=True)
        self.setup_bookmark(is_archived=True, title="term1")
        self.setup_bookmark(is_archived=True, title="term1", tags=[tag])
        self.setup_bookmark(is_archived=True, tags=[tag])

        query = queries.query_archived_bookmark_tags(
            self.user, self.profile, BookmarkSearch(q="!untagged")
        )
        self.assertCountEqual(list(query), [])

        query = queries.query_archived_bookmark_tags(
            self.user, self.profile, BookmarkSearch(q="!untagged term1")
        )
        self.assertCountEqual(list(query), [])

        query = queries.query_archived_bookmark_tags(
            self.user, self.profile, BookmarkSearch(q=f"!untagged #{tag.name}")
        )
        self.assertCountEqual(list(query), [])

    def test_query_bookmark_tags_filter_unread(self):
        unread_bookmarks = self.setup_numbered_bookmarks(5, unread=True, with_tags=True)
        read_bookmarks = self.setup_numbered_bookmarks(5, unread=False, with_tags=True)
        unread_tags = self.get_tags_from_bookmarks(unread_bookmarks)
        read_tags = self.get_tags_from_bookmarks(read_bookmarks)

        # Legacy query filter
        query = queries.query_bookmark_tags(
            self.user, self.profile, BookmarkSearch(q="!unread")
        )
        self.assertCountEqual(list(query), unread_tags)

        # Bookmark search filter - off
        query = queries.query_bookmark_tags(
            self.user,
            self.profile,
            BookmarkSearch(unread=BookmarkSearch.FILTER_UNREAD_OFF),
        )
        self.assertCountEqual(list(query), read_tags + unread_tags)

        # Bookmark search filter - yes
        query = queries.query_bookmark_tags(
            self.user,
            self.profile,
            BookmarkSearch(unread=BookmarkSearch.FILTER_UNREAD_YES),
        )
        self.assertCountEqual(list(query), unread_tags)

        # Bookmark search filter - no
        query = queries.query_bookmark_tags(
            self.user,
            self.profile,
            BookmarkSearch(unread=BookmarkSearch.FILTER_UNREAD_NO),
        )
        self.assertCountEqual(list(query), read_tags)

    def test_query_bookmark_tags_filter_shared(self):
        unshared_bookmarks = self.setup_numbered_bookmarks(5, with_tags=True)
        shared_bookmarks = self.setup_numbered_bookmarks(5, with_tags=True, shared=True)

        unshared_tags = self.get_tags_from_bookmarks(unshared_bookmarks)
        shared_tags = self.get_tags_from_bookmarks(shared_bookmarks)
        all_tags = unshared_tags + shared_tags

        # Filter is off
        search = BookmarkSearch(shared=BookmarkSearch.FILTER_SHARED_OFF)
        query = queries.query_bookmark_tags(self.user, self.profile, search)
        self.assertCountEqual(list(query), all_tags)

        # Filter for shared
        search = BookmarkSearch(shared=BookmarkSearch.FILTER_SHARED_SHARED)
        query = queries.query_bookmark_tags(self.user, self.profile, search)
        self.assertCountEqual(list(query), shared_tags)

        # Filter for unshared
        search = BookmarkSearch(shared=BookmarkSearch.FILTER_SHARED_UNSHARED)
        query = queries.query_bookmark_tags(self.user, self.profile, search)
        self.assertCountEqual(list(query), unshared_tags)

    def test_query_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)
        tag = self.setup_tag()

        shared_bookmarks = [
            self.setup_bookmark(user=user1, shared=True, title="test title"),
            self.setup_bookmark(user=user2, shared=True),
            self.setup_bookmark(user=user3, shared=True, tags=[tag]),
        ]

        # Unshared bookmarks
        self.setup_bookmark(user=user1, shared=False, title="test title")
        self.setup_bookmark(user=user2, shared=False)
        self.setup_bookmark(user=user3, shared=False, tags=[tag])
        self.setup_bookmark(user=user4, shared=True, tags=[tag])

        # Should return shared bookmarks from all users
        query_set = queries.query_shared_bookmarks(
            None, self.profile, BookmarkSearch(q=""), False
        )
        self.assertQueryResult(query_set, [shared_bookmarks])

        # Should respect search query
        query_set = queries.query_shared_bookmarks(
            None, self.profile, BookmarkSearch(q="test title"), False
        )
        self.assertQueryResult(query_set, [[shared_bookmarks[0]]])

        query_set = queries.query_shared_bookmarks(
            None, self.profile, BookmarkSearch(q=f"#{tag.name}"), False
        )
        self.assertQueryResult(query_set, [[shared_bookmarks[2]]])

    def test_query_publicly_shared_bookmarks(self):
        user1 = self.setup_user(enable_sharing=True, enable_public_sharing=True)
        user2 = self.setup_user(enable_sharing=True)

        bookmark1 = self.setup_bookmark(user=user1, shared=True)
        self.setup_bookmark(user=user2, shared=True)

        query_set = queries.query_shared_bookmarks(
            None, self.profile, BookmarkSearch(q=""), True
        )
        self.assertQueryResult(query_set, [[bookmark1]])

    def test_query_shared_bookmark_tags(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_tags = [
            self.setup_tag(user=user1),
            self.setup_tag(user=user2),
            self.setup_tag(user=user3),
        ]

        self.setup_bookmark(user=user1, shared=True, tags=[shared_tags[0]])
        self.setup_bookmark(user=user2, shared=True, tags=[shared_tags[1]])
        self.setup_bookmark(user=user3, shared=True, tags=[shared_tags[2]])

        self.setup_bookmark(user=user1, shared=False, tags=[self.setup_tag(user=user1)])
        self.setup_bookmark(user=user2, shared=False, tags=[self.setup_tag(user=user2)])
        self.setup_bookmark(user=user3, shared=False, tags=[self.setup_tag(user=user3)])
        self.setup_bookmark(user=user4, shared=True, tags=[self.setup_tag(user=user4)])

        query_set = queries.query_shared_bookmark_tags(
            None, self.profile, BookmarkSearch(q=""), False
        )

        self.assertQueryResult(query_set, [shared_tags])

    def test_query_publicly_shared_bookmark_tags(self):
        user1 = self.setup_user(enable_sharing=True, enable_public_sharing=True)
        user2 = self.setup_user(enable_sharing=True)

        tag1 = self.setup_tag(user=user1)
        tag2 = self.setup_tag(user=user2)

        self.setup_bookmark(user=user1, shared=True, tags=[tag1])
        self.setup_bookmark(user=user2, shared=True, tags=[tag2])

        query_set = queries.query_shared_bookmark_tags(
            None, self.profile, BookmarkSearch(q=""), True
        )

        self.assertQueryResult(query_set, [[tag1]])

    def test_query_shared_bookmark_users(self):
        users_with_shared_bookmarks = [
            self.setup_user(enable_sharing=True),
            self.setup_user(enable_sharing=True),
        ]
        users_without_shared_bookmarks = [
            self.setup_user(enable_sharing=True),
            self.setup_user(enable_sharing=True),
            self.setup_user(enable_sharing=False),
        ]

        # Shared bookmarks
        self.setup_bookmark(
            user=users_with_shared_bookmarks[0], shared=True, title="test title"
        )
        self.setup_bookmark(user=users_with_shared_bookmarks[1], shared=True)

        # Unshared bookmarks
        self.setup_bookmark(
            user=users_without_shared_bookmarks[0], shared=False, title="test title"
        )
        self.setup_bookmark(user=users_without_shared_bookmarks[1], shared=False)
        self.setup_bookmark(user=users_without_shared_bookmarks[2], shared=True)

        # Should return users with shared bookmarks
        query_set = queries.query_shared_bookmark_users(
            self.profile, BookmarkSearch(q=""), False
        )
        self.assertQueryResult(query_set, [users_with_shared_bookmarks])

        # Should respect search query
        query_set = queries.query_shared_bookmark_users(
            self.profile, BookmarkSearch(q="test title"), False
        )
        self.assertQueryResult(query_set, [[users_with_shared_bookmarks[0]]])

    def test_query_publicly_shared_bookmark_users(self):
        user1 = self.setup_user(enable_sharing=True, enable_public_sharing=True)
        user2 = self.setup_user(enable_sharing=True)

        self.setup_bookmark(user=user1, shared=True)
        self.setup_bookmark(user=user2, shared=True)

        query_set = queries.query_shared_bookmark_users(
            self.profile, BookmarkSearch(q=""), True
        )
        self.assertQueryResult(query_set, [[user1]])

    def test_sorty_by_date_added_asc(self):
        search = BookmarkSearch(sort=BookmarkSearch.SORT_ADDED_ASC)

        bookmarks = [
            self.setup_bookmark(
                added=timezone.datetime(2020, 1, 1, tzinfo=datetime.UTC)
            ),
            self.setup_bookmark(
                added=timezone.datetime(2021, 2, 1, tzinfo=datetime.UTC)
            ),
            self.setup_bookmark(
                added=timezone.datetime(2022, 3, 1, tzinfo=datetime.UTC)
            ),
            self.setup_bookmark(
                added=timezone.datetime(2023, 4, 1, tzinfo=datetime.UTC)
            ),
            self.setup_bookmark(
                added=timezone.datetime(2022, 5, 1, tzinfo=datetime.UTC)
            ),
            self.setup_bookmark(
                added=timezone.datetime(2021, 6, 1, tzinfo=datetime.UTC)
            ),
            self.setup_bookmark(
                added=timezone.datetime(2020, 7, 1, tzinfo=datetime.UTC)
            ),
        ]
        sorted_bookmarks = sorted(bookmarks, key=lambda b: b.date_added)

        query = queries.query_bookmarks(self.user, self.profile, search)
        self.assertEqual(list(query), sorted_bookmarks)

    def test_sorty_by_date_added_desc(self):
        search = BookmarkSearch(sort=BookmarkSearch.SORT_ADDED_DESC)

        bookmarks = [
            self.setup_bookmark(
                added=timezone.datetime(2020, 1, 1, tzinfo=datetime.UTC)
            ),
            self.setup_bookmark(
                added=timezone.datetime(2021, 2, 1, tzinfo=datetime.UTC)
            ),
            self.setup_bookmark(
                added=timezone.datetime(2022, 3, 1, tzinfo=datetime.UTC)
            ),
            self.setup_bookmark(
                added=timezone.datetime(2023, 4, 1, tzinfo=datetime.UTC)
            ),
            self.setup_bookmark(
                added=timezone.datetime(2022, 5, 1, tzinfo=datetime.UTC)
            ),
            self.setup_bookmark(
                added=timezone.datetime(2021, 6, 1, tzinfo=datetime.UTC)
            ),
            self.setup_bookmark(
                added=timezone.datetime(2020, 7, 1, tzinfo=datetime.UTC)
            ),
        ]
        sorted_bookmarks = sorted(bookmarks, key=lambda b: b.date_added, reverse=True)

        query = queries.query_bookmarks(self.user, self.profile, search)
        self.assertEqual(list(query), sorted_bookmarks)

    def setup_title_sort_data(self):
        # lots of combinations to test effective title logic
        bookmarks = [
            self.setup_bookmark(title="a_1_1"),
            self.setup_bookmark(title="A_1_2"),
            self.setup_bookmark(title="b_1_1"),
            self.setup_bookmark(title="B_1_2"),
            self.setup_bookmark(title="", url="a_3_1"),
            self.setup_bookmark(title="", url="A_3_2"),
            self.setup_bookmark(title="", url="b_3_1"),
            self.setup_bookmark(title="", url="B_3_2"),
            self.setup_bookmark(title="a_5_1", url="0"),
            self.setup_bookmark(title="A_5_2", url="0"),
            self.setup_bookmark(title="b_5_1", url="0"),
            self.setup_bookmark(title="B_5_2", url="0"),
            self.setup_bookmark(title="", url="0"),
            self.setup_bookmark(title="", url="0"),
            self.setup_bookmark(title="", url="0"),
            self.setup_bookmark(title="", url="0"),
        ]
        return bookmarks

    def test_sort_by_title_asc(self):
        search = BookmarkSearch(sort=BookmarkSearch.SORT_TITLE_ASC)

        bookmarks = self.setup_title_sort_data()
        sorted_bookmarks = sorted(bookmarks, key=lambda b: b.resolved_title.lower())

        query = queries.query_bookmarks(self.user, self.profile, search)

        # Use resolved title for comparison as Postgres returns bookmarks with same resolved title in random order
        expected_effective_titles = [b.resolved_title for b in sorted_bookmarks]
        actual_effective_titles = [b.resolved_title for b in query]
        self.assertEqual(expected_effective_titles, actual_effective_titles)

    def test_sort_by_title_desc(self):
        search = BookmarkSearch(sort=BookmarkSearch.SORT_TITLE_DESC)

        bookmarks = self.setup_title_sort_data()
        sorted_bookmarks = sorted(
            bookmarks, key=lambda b: b.resolved_title.lower(), reverse=True
        )

        query = queries.query_bookmarks(self.user, self.profile, search)

        # Use resolved title for comparison as Postgres returns bookmarks with same resolved title in random order
        expected_effective_titles = [b.resolved_title for b in sorted_bookmarks]
        actual_effective_titles = [b.resolved_title for b in query]
        self.assertEqual(expected_effective_titles, actual_effective_titles)

    def test_query_bookmarks_filter_modified_since(self):
        # Create bookmarks with different modification dates
        older_bookmark = self.setup_bookmark(title="old bookmark")
        recent_bookmark = self.setup_bookmark(title="recent bookmark")

        # Modify date field on bookmark directly to test modified_since
        older_bookmark.date_modified = timezone.datetime(
            2025, 1, 1, tzinfo=datetime.UTC
        )
        older_bookmark.save()
        recent_bookmark.date_modified = timezone.datetime(
            2025, 5, 15, tzinfo=datetime.UTC
        )
        recent_bookmark.save()

        # Test with date between the two bookmarks
        search = BookmarkSearch(modified_since="2025-03-01T00:00:00Z")
        query = queries.query_bookmarks(self.user, self.profile, search)
        self.assertCountEqual(list(query), [recent_bookmark])

        # Test with date before both bookmarks
        search = BookmarkSearch(modified_since="2024-12-31T00:00:00Z")
        query = queries.query_bookmarks(self.user, self.profile, search)
        self.assertCountEqual(list(query), [older_bookmark, recent_bookmark])

        # Test with date after both bookmarks
        search = BookmarkSearch(modified_since="2025-05-16T00:00:00Z")
        query = queries.query_bookmarks(self.user, self.profile, search)
        self.assertCountEqual(list(query), [])

        # Test with no modified_since - should return all bookmarks
        search = BookmarkSearch()
        query = queries.query_bookmarks(self.user, self.profile, search)
        self.assertCountEqual(list(query), [older_bookmark, recent_bookmark])

        # Test with invalid date format - should be ignored
        search = BookmarkSearch(modified_since="invalid-date")
        query = queries.query_bookmarks(self.user, self.profile, search)
        self.assertCountEqual(list(query), [older_bookmark, recent_bookmark])

    def test_query_bookmarks_filter_added_since(self):
        # Create bookmarks with different dates
        older_bookmark = self.setup_bookmark(
            title="old bookmark",
            added=timezone.datetime(2025, 1, 1, tzinfo=datetime.UTC),
        )
        recent_bookmark = self.setup_bookmark(
            title="recent bookmark",
            added=timezone.datetime(2025, 5, 15, tzinfo=datetime.UTC),
        )

        # Test with date between the two bookmarks
        search = BookmarkSearch(added_since="2025-03-01T00:00:00Z")
        query = queries.query_bookmarks(self.user, self.profile, search)
        self.assertCountEqual(list(query), [recent_bookmark])

        # Test with date before both bookmarks
        search = BookmarkSearch(added_since="2024-12-31T00:00:00Z")
        query = queries.query_bookmarks(self.user, self.profile, search)
        self.assertCountEqual(list(query), [older_bookmark, recent_bookmark])

        # Test with date after both bookmarks
        search = BookmarkSearch(added_since="2025-05-16T00:00:00Z")
        query = queries.query_bookmarks(self.user, self.profile, search)
        self.assertCountEqual(list(query), [])

        # Test with no added_since - should return all bookmarks
        search = BookmarkSearch()
        query = queries.query_bookmarks(self.user, self.profile, search)
        self.assertCountEqual(list(query), [older_bookmark, recent_bookmark])

        # Test with invalid date format - should be ignored
        search = BookmarkSearch(added_since="invalid-date")
        query = queries.query_bookmarks(self.user, self.profile, search)
        self.assertCountEqual(list(query), [older_bookmark, recent_bookmark])

    def test_query_bookmarks_with_bundle_search_terms(self):
        bundle = self.setup_bundle(search="search_term_A search_term_B")

        matching_bookmarks = [
            self.setup_bookmark(
                title="search_term_A content", description="search_term_B also here"
            ),
            self.setup_bookmark(url="http://example.com/search_term_A/search_term_B"),
        ]

        # Bookmarks that should not match
        self.setup_bookmark(title="search_term_A only")
        self.setup_bookmark(description="search_term_B only")
        self.setup_bookmark(title="unrelated content")

        query = queries.query_bookmarks(
            self.user, self.profile, BookmarkSearch(q="", bundle=bundle)
        )
        self.assertQueryResult(query, [matching_bookmarks])

    def test_query_bookmarks_with_search_and_bundle_search_terms(self):
        bundle = self.setup_bundle(search="bundle_term_B")
        search = BookmarkSearch(q="search_term_A", bundle=bundle)

        matching_bookmarks = [
            self.setup_bookmark(
                title="search_term_A content", description="bundle_term_B also here"
            )
        ]

        # Bookmarks that should not match
        self.setup_bookmark(title="search_term_A only")
        self.setup_bookmark(description="bundle_term_B only")
        self.setup_bookmark(title="unrelated content")

        query = queries.query_bookmarks(self.user, self.profile, search)
        self.assertQueryResult(query, [matching_bookmarks])

    def test_query_bookmarks_with_bundle_any_tags(self):
        bundle = self.setup_bundle(any_tags="bundleTag1 bundleTag2")

        tag1 = self.setup_tag(name="bundleTag1")
        tag2 = self.setup_tag(name="bundleTag2")
        other_tag = self.setup_tag(name="otherTag")

        matching_bookmarks = [
            self.setup_bookmark(tags=[tag1]),
            self.setup_bookmark(tags=[tag2]),
            self.setup_bookmark(tags=[tag1, tag2]),
        ]

        # Bookmarks that should not match
        self.setup_bookmark(tags=[other_tag])
        self.setup_bookmark()

        query = queries.query_bookmarks(
            self.user, self.profile, BookmarkSearch(q="", bundle=bundle)
        )
        self.assertQueryResult(query, [matching_bookmarks])

    def test_query_bookmarks_with_search_tags_and_bundle_any_tags(self):
        bundle = self.setup_bundle(any_tags="bundleTagA bundleTagB")
        search = BookmarkSearch(q="#searchTag1 #searchTag2", bundle=bundle)

        search_tag1 = self.setup_tag(name="searchTag1")
        search_tag2 = self.setup_tag(name="searchTag2")
        bundle_tag_a = self.setup_tag(name="bundleTagA")
        bundle_tag_b = self.setup_tag(name="bundleTagB")
        other_tag = self.setup_tag(name="otherTag")

        matching_bookmarks = [
            self.setup_bookmark(tags=[search_tag1, search_tag2, bundle_tag_a]),
            self.setup_bookmark(tags=[search_tag1, search_tag2, bundle_tag_b]),
            self.setup_bookmark(
                tags=[search_tag1, search_tag2, bundle_tag_a, bundle_tag_b]
            ),
        ]

        # Bookmarks that should not match
        self.setup_bookmark(tags=[search_tag1, search_tag2, other_tag])
        self.setup_bookmark(tags=[search_tag1, search_tag2])
        self.setup_bookmark(tags=[search_tag1, bundle_tag_a])
        self.setup_bookmark(tags=[search_tag2, bundle_tag_b])
        self.setup_bookmark(tags=[bundle_tag_a])
        self.setup_bookmark(tags=[bundle_tag_b])
        self.setup_bookmark(tags=[bundle_tag_a, bundle_tag_b])
        self.setup_bookmark(tags=[other_tag])
        self.setup_bookmark()

        query = queries.query_bookmarks(self.user, self.profile, search)
        self.assertQueryResult(query, [matching_bookmarks])

    def test_query_bookmarks_with_bundle_all_tags(self):
        bundle = self.setup_bundle(all_tags="bundleTag1 bundleTag2")

        tag1 = self.setup_tag(name="bundleTag1")
        tag2 = self.setup_tag(name="bundleTag2")
        other_tag = self.setup_tag(name="otherTag")

        matching_bookmarks = [self.setup_bookmark(tags=[tag1, tag2])]

        # Bookmarks that should not match
        self.setup_bookmark(tags=[tag1])
        self.setup_bookmark(tags=[tag2])
        self.setup_bookmark(tags=[tag1, other_tag])
        self.setup_bookmark(tags=[other_tag])
        self.setup_bookmark()

        query = queries.query_bookmarks(
            self.user, self.profile, BookmarkSearch(q="", bundle=bundle)
        )
        self.assertQueryResult(query, [matching_bookmarks])

    def test_query_bookmarks_with_search_tags_and_bundle_all_tags(self):
        bundle = self.setup_bundle(all_tags="bundleTagA bundleTagB")
        search = BookmarkSearch(q="#searchTag1 #searchTag2", bundle=bundle)

        search_tag1 = self.setup_tag(name="searchTag1")
        search_tag2 = self.setup_tag(name="searchTag2")
        bundle_tag_a = self.setup_tag(name="bundleTagA")
        bundle_tag_b = self.setup_tag(name="bundleTagB")
        other_tag = self.setup_tag(name="otherTag")

        matching_bookmarks = [
            self.setup_bookmark(
                tags=[search_tag1, search_tag2, bundle_tag_a, bundle_tag_b]
            )
        ]

        # Bookmarks that should not match
        self.setup_bookmark(tags=[search_tag1, search_tag2, bundle_tag_a])
        self.setup_bookmark(tags=[search_tag1, bundle_tag_a, bundle_tag_b])
        self.setup_bookmark(tags=[search_tag1, search_tag2])
        self.setup_bookmark(tags=[bundle_tag_a, bundle_tag_b])
        self.setup_bookmark(tags=[search_tag1, bundle_tag_a])
        self.setup_bookmark(tags=[other_tag])
        self.setup_bookmark()

        query = queries.query_bookmarks(self.user, self.profile, search)
        self.assertQueryResult(query, [matching_bookmarks])

    def test_query_bookmarks_with_bundle_excluded_tags(self):
        bundle = self.setup_bundle(excluded_tags="excludeTag1 excludeTag2")

        exclude_tag1 = self.setup_tag(name="excludeTag1")
        exclude_tag2 = self.setup_tag(name="excludeTag2")
        keep_tag = self.setup_tag(name="keepTag")
        keep_other_tag = self.setup_tag(name="keepOtherTag")

        matching_bookmarks = [
            self.setup_bookmark(tags=[keep_tag]),
            self.setup_bookmark(tags=[keep_other_tag]),
            self.setup_bookmark(tags=[keep_tag, keep_other_tag]),
            self.setup_bookmark(),
        ]

        # Bookmarks that should not be returned
        self.setup_bookmark(tags=[exclude_tag1])
        self.setup_bookmark(tags=[exclude_tag2])
        self.setup_bookmark(tags=[exclude_tag1, keep_tag])
        self.setup_bookmark(tags=[exclude_tag2, keep_tag])
        self.setup_bookmark(tags=[exclude_tag1, exclude_tag2])
        self.setup_bookmark(tags=[exclude_tag1, exclude_tag2, keep_tag])

        query = queries.query_bookmarks(
            self.user, self.profile, BookmarkSearch(q="", bundle=bundle)
        )
        self.assertQueryResult(query, [matching_bookmarks])

    def test_query_bookmarks_with_bundle_combined_tags(self):
        bundle = self.setup_bundle(
            any_tags="anyTagA anyTagB",
            all_tags="allTag1 allTag2",
            excluded_tags="excludedTag",
        )

        any_tag_a = self.setup_tag(name="anyTagA")
        any_tag_b = self.setup_tag(name="anyTagB")
        all_tag_1 = self.setup_tag(name="allTag1")
        all_tag_2 = self.setup_tag(name="allTag2")
        other_tag = self.setup_tag(name="otherTag")
        excluded_tag = self.setup_tag(name="excludedTag")

        matching_bookmarks = [
            self.setup_bookmark(tags=[any_tag_a, all_tag_1, all_tag_2]),
            self.setup_bookmark(tags=[any_tag_b, all_tag_1, all_tag_2]),
            self.setup_bookmark(tags=[any_tag_a, any_tag_b, all_tag_1, all_tag_2]),
            self.setup_bookmark(tags=[any_tag_a, all_tag_1, all_tag_2, other_tag]),
            self.setup_bookmark(tags=[any_tag_b, all_tag_1, all_tag_2, other_tag]),
        ]

        # Bookmarks that should not match
        self.setup_bookmark(tags=[any_tag_a, all_tag_1])
        self.setup_bookmark(tags=[any_tag_b, all_tag_2])
        self.setup_bookmark(tags=[any_tag_a, any_tag_b, all_tag_1])
        self.setup_bookmark(tags=[all_tag_1, all_tag_2])
        self.setup_bookmark(tags=[all_tag_1, all_tag_2, other_tag])
        self.setup_bookmark(tags=[any_tag_a])
        self.setup_bookmark(tags=[any_tag_b])
        self.setup_bookmark(tags=[all_tag_1])
        self.setup_bookmark(tags=[all_tag_2])
        self.setup_bookmark(tags=[any_tag_a, all_tag_1, all_tag_2, excluded_tag])
        self.setup_bookmark(tags=[any_tag_b, all_tag_1, all_tag_2, excluded_tag])
        self.setup_bookmark(tags=[other_tag])
        self.setup_bookmark()

        query = queries.query_bookmarks(
            self.user, self.profile, BookmarkSearch(q="", bundle=bundle)
        )
        self.assertQueryResult(query, [matching_bookmarks])

    def test_query_bookmarks_with_bundle_filter_unread(self):
        unread_bookmarks = [
            self.setup_bookmark(unread=True),
            self.setup_bookmark(unread=True),
        ]
        read_bookmarks = [
            self.setup_bookmark(unread=False),
            self.setup_bookmark(unread=False),
        ]

        # Filter unread
        bundle = self.setup_bundle(filter_unread=BookmarkBundle.FILTER_STATE_YES)
        query = queries.query_bookmarks(
            self.user, self.profile, BookmarkSearch(q="", bundle=bundle)
        )
        self.assertQueryResult(query, [unread_bookmarks])

        # Filter read
        bundle = self.setup_bundle(filter_unread=BookmarkBundle.FILTER_STATE_NO)
        query = queries.query_bookmarks(
            self.user, self.profile, BookmarkSearch(q="", bundle=bundle)
        )
        self.assertQueryResult(query, [read_bookmarks])

        # Filter off
        bundle = self.setup_bundle(filter_unread=BookmarkBundle.FILTER_STATE_OFF)
        query = queries.query_bookmarks(
            self.user, self.profile, BookmarkSearch(q="", bundle=bundle)
        )
        self.assertQueryResult(query, [unread_bookmarks, read_bookmarks])

    def test_query_bookmarks_with_bundle_filter_shared(self):
        shared_bookmarks = [
            self.setup_bookmark(shared=True),
            self.setup_bookmark(shared=True),
        ]
        unshared_bookmarks = [
            self.setup_bookmark(shared=False),
            self.setup_bookmark(shared=False),
        ]

        # Filter shared
        bundle = self.setup_bundle(filter_shared=BookmarkBundle.FILTER_STATE_YES)
        query = queries.query_bookmarks(
            self.user, self.profile, BookmarkSearch(q="", bundle=bundle)
        )
        self.assertQueryResult(query, [shared_bookmarks])

        # Filter unshared
        bundle = self.setup_bundle(filter_shared=BookmarkBundle.FILTER_STATE_NO)
        query = queries.query_bookmarks(
            self.user, self.profile, BookmarkSearch(q="", bundle=bundle)
        )
        self.assertQueryResult(query, [unshared_bookmarks])

        # Filter off
        bundle = self.setup_bundle(filter_shared=BookmarkBundle.FILTER_STATE_OFF)
        query = queries.query_bookmarks(
            self.user, self.profile, BookmarkSearch(q="", bundle=bundle)
        )
        self.assertQueryResult(query, [shared_bookmarks, unshared_bookmarks])

    def test_query_bookmarks_with_bundle_unread_shared_filters_combined(self):
        bundle = self.setup_bundle(
            search="python",
            filter_unread=BookmarkBundle.FILTER_STATE_YES,
            filter_shared=BookmarkBundle.FILTER_STATE_NO,
        )

        matching_bookmarks = [
            self.setup_bookmark(title="Python Tutorial", unread=True, shared=False),
        ]

        # Bookmarks that should not match
        self.setup_bookmark(title="Python Guide", unread=False, shared=False)
        self.setup_bookmark(title="Python Docs", unread=True, shared=True)
        self.setup_bookmark(title="Java Guide", unread=True, shared=False)

        query = queries.query_bookmarks(
            self.user, self.profile, BookmarkSearch(q="", bundle=bundle)
        )
        self.assertQueryResult(query, [matching_bookmarks])

    def test_query_archived_bookmarks_with_bundle(self):
        bundle = self.setup_bundle(any_tags="bundleTag1 bundleTag2")

        tag1 = self.setup_tag(name="bundleTag1")
        tag2 = self.setup_tag(name="bundleTag2")
        other_tag = self.setup_tag(name="otherTag")

        matching_bookmarks = [
            self.setup_bookmark(is_archived=True, tags=[tag1]),
            self.setup_bookmark(is_archived=True, tags=[tag2]),
            self.setup_bookmark(is_archived=True, tags=[tag1, tag2]),
        ]

        # Bookmarks that should not match
        self.setup_bookmark(is_archived=True, tags=[other_tag])
        self.setup_bookmark(is_archived=True)
        self.setup_bookmark(tags=[tag1])
        self.setup_bookmark(tags=[tag2])
        self.setup_bookmark(tags=[tag1, tag2])

        query = queries.query_archived_bookmarks(
            self.user, self.profile, BookmarkSearch(q="", bundle=bundle)
        )
        self.assertQueryResult(query, [matching_bookmarks])

    def test_query_shared_bookmarks_with_bundle(self):
        user1 = self.setup_user(enable_sharing=True)
        user2 = self.setup_user(enable_sharing=True)

        bundle = self.setup_bundle(any_tags="bundleTag1 bundleTag2")

        tag1 = self.setup_tag(name="bundleTag1")
        tag2 = self.setup_tag(name="bundleTag2")
        other_tag = self.setup_tag(name="otherTag")

        matching_bookmarks = [
            self.setup_bookmark(user=user1, shared=True, tags=[tag1]),
            self.setup_bookmark(user=user2, shared=True, tags=[tag2]),
            self.setup_bookmark(user=user1, shared=True, tags=[tag1, tag2]),
        ]

        # Bookmarks that should not match
        self.setup_bookmark(user=user1, shared=True, tags=[other_tag])
        self.setup_bookmark(user=user2, shared=True)
        self.setup_bookmark(user=user1, shared=False, tags=[tag1])
        self.setup_bookmark(user=user2, shared=False, tags=[tag2])
        self.setup_bookmark(user=user1, shared=False, tags=[tag1, tag2])

        query = queries.query_shared_bookmarks(
            None, self.profile, BookmarkSearch(q="", bundle=bundle), False
        )
        self.assertQueryResult(query, [matching_bookmarks])


# Legacy search should be covered by basic test suite which was effectively the
# full test suite before advanced search was introduced.
class QueriesLegacySearchTestCase(QueriesBasicTestCase):
    def setUp(self):
        super().setUp()
        self.profile.legacy_search = True
        self.profile.save()


class QueriesAdvancedSearchTestCase(TestCase, BookmarkFactoryMixin):
    def setUp(self):
        self.user = self.get_or_create_test_user()
        self.profile = self.user.profile

        self.python_bookmark = self.setup_bookmark(
            title="Python Tutorial",
            tags=[self.setup_tag(name="python"), self.setup_tag(name="tutorial")],
        )
        self.java_bookmark = self.setup_bookmark(
            title="Java Guide",
            tags=[self.setup_tag(name="java"), self.setup_tag(name="programming")],
        )
        self.deprecated_python_bookmark = self.setup_bookmark(
            title="Old Python Guide",
            tags=[self.setup_tag(name="python"), self.setup_tag(name="deprecated")],
        )
        self.javascript_tutorial = self.setup_bookmark(
            title="JavaScript Basics",
            tags=[self.setup_tag(name="javascript"), self.setup_tag(name="tutorial")],
        )
        self.web_development = self.setup_bookmark(
            title="Web Development with React",
            description="Modern web development",
            tags=[self.setup_tag(name="react"), self.setup_tag(name="web")],
        )

    def test_explicit_and_operator(self):
        search = BookmarkSearch(q="python AND tutorial")
        query = queries.query_bookmarks(self.user, self.profile, search)
        self.assertCountEqual(list(query), [self.python_bookmark])

    def test_or_operator(self):
        search = BookmarkSearch(q="#python OR #java")
        query = queries.query_bookmarks(self.user, self.profile, search)
        self.assertCountEqual(
            list(query),
            [self.python_bookmark, self.java_bookmark, self.deprecated_python_bookmark],
        )

    def test_not_operator(self):
        search = BookmarkSearch(q="#python AND NOT #deprecated")
        query = queries.query_bookmarks(self.user, self.profile, search)
        self.assertCountEqual(list(query), [self.python_bookmark])

    def test_implicit_and_between_terms(self):
        search = BookmarkSearch(q="web development")
        query = queries.query_bookmarks(self.user, self.profile, search)
        self.assertCountEqual(list(query), [self.web_development])

        search = BookmarkSearch(q="python tutorial")
        query = queries.query_bookmarks(self.user, self.profile, search)
        self.assertCountEqual(list(query), [self.python_bookmark])

    def test_implicit_and_between_tags(self):
        search = BookmarkSearch(q="#python #tutorial")
        query = queries.query_bookmarks(self.user, self.profile, search)
        self.assertCountEqual(list(query), [self.python_bookmark])

    def test_nested_and_expression(self):
        search = BookmarkSearch(q="nonexistingterm OR (#python AND #tutorial)")
        query = queries.query_bookmarks(self.user, self.profile, search)
        self.assertCountEqual(list(query), [self.python_bookmark])

        search = BookmarkSearch(
            q="(#javascript AND #tutorial) OR (#python AND #tutorial)"
        )
        query = queries.query_bookmarks(self.user, self.profile, search)
        self.assertCountEqual(
            list(query), [self.javascript_tutorial, self.python_bookmark]
        )

    def test_mixed_terms_and_tags_with_operators(self):
        # Set lax mode to allow term matching against tags
        self.profile.tag_search = self.profile.TAG_SEARCH_LAX
        self.profile.save()

        search = BookmarkSearch(q="(tutorial OR guide) AND #python")
        query = queries.query_bookmarks(self.user, self.profile, search)
        self.assertCountEqual(
            list(query), [self.python_bookmark, self.deprecated_python_bookmark]
        )

    def test_parentheses(self):
        # Set lax mode to allow term matching against tags
        self.profile.tag_search = self.profile.TAG_SEARCH_LAX
        self.profile.save()

        # Without parentheses
        search = BookmarkSearch(q="python AND tutorial OR javascript AND tutorial")
        query = queries.query_bookmarks(self.user, self.profile, search)
        self.assertCountEqual(
            list(query), [self.python_bookmark, self.javascript_tutorial]
        )

        # With parentheses
        search = BookmarkSearch(q="(python OR javascript) AND tutorial")
        query = queries.query_bookmarks(self.user, self.profile, search)
        self.assertCountEqual(
            list(query), [self.python_bookmark, self.javascript_tutorial]
        )

    def test_complex_query_with_all_operators(self):
        # Set lax mode to allow term matching against tags
        self.profile.tag_search = self.profile.TAG_SEARCH_LAX
        self.profile.save()

        search = BookmarkSearch(
            q="(#python OR #javascript) AND tutorial AND NOT #deprecated"
        )
        query = queries.query_bookmarks(self.user, self.profile, search)
        self.assertCountEqual(
            list(query), [self.python_bookmark, self.javascript_tutorial]
        )

    def test_quoted_strings_with_operators(self):
        # Set lax mode to allow term matching against tags
        self.profile.tag_search = self.profile.TAG_SEARCH_LAX
        self.profile.save()

        search = BookmarkSearch(q='"Web Development" OR tutorial')
        query = queries.query_bookmarks(self.user, self.profile, search)
        self.assertCountEqual(
            list(query),
            [self.web_development, self.python_bookmark, self.javascript_tutorial],
        )

    def test_implicit_and_with_quoted_strings(self):
        search = BookmarkSearch(q='"Web Development" react')
        query = queries.query_bookmarks(self.user, self.profile, search)
        self.assertCountEqual(list(query), [self.web_development])

    def test_empty_query(self):
        # empty query returns all bookmarks
        search = BookmarkSearch(q="")
        query = queries.query_bookmarks(self.user, self.profile, search)
        expected = [
            self.python_bookmark,
            self.java_bookmark,
            self.deprecated_python_bookmark,
            self.javascript_tutorial,
            self.web_development,
        ]
        self.assertCountEqual(list(query), expected)

    def test_unparseable_query_returns_no_results(self):
        # Use a query that causes a parse error (unclosed parenthesis)
        search = BookmarkSearch(q="(python AND tutorial")
        query = queries.query_bookmarks(self.user, self.profile, search)
        self.assertCountEqual(list(query), [])


class GetTagsForQueryTestCase(TestCase, BookmarkFactoryMixin):
    def setUp(self):
        self.user = self.get_or_create_test_user()
        self.profile = self.user.profile

    def test_returns_tags_matching_query(self):
        python_tag = self.setup_tag(name="python")
        django_tag = self.setup_tag(name="django")
        self.setup_tag(name="unused")

        result = queries.get_tags_for_query(
            self.user, self.profile, "#python and #django"
        )
        self.assertCountEqual(list(result), [python_tag, django_tag])

    def test_case_insensitive_matching(self):
        python_tag = self.setup_tag(name="Python")

        result = queries.get_tags_for_query(self.user, self.profile, "#python")
        self.assertCountEqual(list(result), [python_tag])

        # having two tags with the same name returns both for now
        other_python_tag = self.setup_tag(name="python")

        result = queries.get_tags_for_query(self.user, self.profile, "#python")
        self.assertCountEqual(list(result), [python_tag, other_python_tag])

    def test_lax_mode_includes_terms(self):
        python_tag = self.setup_tag(name="python")
        django_tag = self.setup_tag(name="django")

        self.profile.tag_search = UserProfile.TAG_SEARCH_LAX
        self.profile.save()

        result = queries.get_tags_for_query(
            self.user, self.profile, "#python and django"
        )
        self.assertCountEqual(list(result), [python_tag, django_tag])

    def test_strict_mode_excludes_terms(self):
        python_tag = self.setup_tag(name="python")
        self.setup_tag(name="django")

        result = queries.get_tags_for_query(
            self.user, self.profile, "#python and django"
        )
        self.assertCountEqual(list(result), [python_tag])

    def test_only_returns_user_tags(self):
        python_tag = self.setup_tag(name="python")

        other_user = self.setup_user()
        other_python = self.setup_tag(name="python", user=other_user)
        other_django = self.setup_tag(name="django", user=other_user)

        result = queries.get_tags_for_query(
            self.user, self.profile, "#python and #django"
        )
        self.assertCountEqual(list(result), [python_tag])
        self.assertNotIn(other_python, list(result))
        self.assertNotIn(other_django, list(result))

    def test_empty_query_returns_no_tags(self):
        self.setup_tag(name="python")

        result = queries.get_tags_for_query(self.user, self.profile, "")
        self.assertCountEqual(list(result), [])

    def test_query_with_no_tags_returns_empty(self):
        self.setup_tag(name="python")

        result = queries.get_tags_for_query(self.user, self.profile, "!unread")
        self.assertCountEqual(list(result), [])

    def test_nonexistent_tag_returns_empty(self):
        self.setup_tag(name="python")

        result = queries.get_tags_for_query(self.user, self.profile, "#ruby")
        self.assertCountEqual(list(result), [])


class GetSharedTagsForQueryTestCase(TestCase, BookmarkFactoryMixin):
    def setUp(self):
        self.user = self.get_or_create_test_user()
        self.profile = self.user.profile
        self.profile.enable_sharing = True
        self.profile.save()

    def test_returns_tags_from_shared_bookmarks(self):
        python_tag = self.setup_tag(name="python")
        self.setup_tag(name="django")
        self.setup_bookmark(shared=True, tags=[python_tag])

        result = queries.get_shared_tags_for_query(
            None, self.profile, "#python and #django", public_only=False
        )
        self.assertCountEqual(list(result), [python_tag])

    def test_excludes_tags_from_non_shared_bookmarks(self):
        python_tag = self.setup_tag(name="python")
        self.setup_tag(name="django")
        self.setup_bookmark(shared=False, tags=[python_tag])

        result = queries.get_shared_tags_for_query(
            None, self.profile, "#python and #django", public_only=False
        )
        self.assertCountEqual(list(result), [])

    def test_respects_sharing_enabled_setting(self):
        self.profile.enable_sharing = False
        self.profile.save()

        python_tag = self.setup_tag(name="python")
        self.setup_tag(name="django")
        self.setup_bookmark(shared=True, tags=[python_tag])

        result = queries.get_shared_tags_for_query(
            None, self.profile, "#python and #django", public_only=False
        )
        self.assertCountEqual(list(result), [])

    def test_public_only_flag(self):
        # public sharing disabled
        python_tag = self.setup_tag(name="python")
        self.setup_tag(name="django")
        self.setup_bookmark(shared=True, tags=[python_tag])

        result = queries.get_shared_tags_for_query(
            None, self.profile, "#python and #django", public_only=True
        )
        self.assertCountEqual(list(result), [])

        # public sharing enabled
        self.profile.enable_public_sharing = True
        self.profile.save()

        result = queries.get_shared_tags_for_query(
            None, self.profile, "#python and #django", public_only=True
        )
        self.assertCountEqual(list(result), [python_tag])

    def test_filters_by_user(self):
        python_tag = self.setup_tag(name="python")
        self.setup_tag(name="django")
        self.setup_bookmark(shared=True, tags=[python_tag])

        other_user = self.setup_user()
        other_user.profile.enable_sharing = True
        other_user.profile.save()
        other_tag = self.setup_tag(name="python", user=other_user)
        self.setup_bookmark(shared=True, tags=[other_tag], user=other_user)

        result = queries.get_shared_tags_for_query(
            self.user, self.profile, "#python and #django", public_only=False
        )
        self.assertCountEqual(list(result), [python_tag])
        self.assertNotIn(other_tag, list(result))


================================================
FILE: bookmarks/tests/test_root_view.py
================================================
from django.test import TestCase
from django.urls import reverse

from bookmarks.models import GlobalSettings
from bookmarks.tests.helpers import BookmarkFactoryMixin


class RootViewTestCase(TestCase, BookmarkFactoryMixin):
    def test_unauthenticated_user_redirect_to_login_by_default(self):
        response = self.client.get(reverse("linkding:root"))
        self.assertRedirects(response, reverse("login"))

    def test_unauthenticated_redirect_to_shared_bookmarks_if_configured_in_global_settings(
        self,
    ):
        settings = GlobalSettings.get()
        settings.landing_page = GlobalSettings.LANDING_PAGE_SHARED_BOOKMARKS
        settings.save()

        response = self.client.get(reverse("linkding:root"))
        self.assertRedirects(response, reverse("linkding:bookmarks.shared"))

    def test_authenticated_user_always_redirected_to_bookmarks(self):
        self.client.force_login(self.get_or_create_test_user())

        response = self.client.get(reverse("linkding:root"))
        self.assertRedirects(response, reverse("linkding:bookmarks.index"))

        settings = GlobalSettings.get()
        settings.landing_page = GlobalSettings.LANDING_PAGE_SHARED_BOOKMARKS
        settings.save()

        response = self.client.get(reverse("linkding:root"))
        self.assertRedirects(response, reverse("linkding:bookmarks.index"))

        settings.landing_page = GlobalSettings.LANDING_PAGE_LOGIN
        settings.save()

        response = self.client.get(reverse("linkding:root"))
        self.assertRedirects(response, reverse("linkding:bookmarks.index"))


================================================
FILE: bookmarks/tests/test_search_query_parser.py
================================================
from django.test import TestCase

from bookmarks.models import UserProfile
from bookmarks.services.search_query_parser import (
    AndExpression,
    NotExpression,
    OrExpression,
    SearchExpression,
    SearchQueryParseError,
    SearchQueryTokenizer,
    SpecialKeywordExpression,
    TagExpression,
    TermExpression,
    TokenType,
    expression_to_string,
    extract_tag_names_from_query,
    parse_search_query,
    strip_tag_from_query,
)


def _term(term: str) -> TermExpression:
    return TermExpression(term)


def _tag(tag: str) -> TagExpression:
    return TagExpression(tag)


def _and(left: SearchExpression, right: SearchExpression) -> AndExpression:
    return AndExpression(left, right)


def _or(left: SearchExpression, right: SearchExpression) -> OrExpression:
    return OrExpression(left, right)


def _not(operand: SearchExpression) -> NotExpression:
    return NotExpression(operand)


def _keyword(keyword: str) -> SpecialKeywordExpression:
    return SpecialKeywordExpression(keyword)


class SearchQueryTokenizerTest(TestCase):
    def test_empty_query(self):
        tokenizer = SearchQueryTokenizer("")
        tokens = tokenizer.tokenize()
        self.assertEqual(len(tokens), 1)
        self.assertEqual(tokens[0].type, TokenType.EOF)

    def test_whitespace_only_query(self):
        tokenizer = SearchQueryTokenizer("   ")
        tokens = tokenizer.tokenize()
        self.assertEqual(len(tokens), 1)
        self.assertEqual(tokens[0].type, TokenType.EOF)

    def test_single_term(self):
        tokenizer = SearchQueryTokenizer("programming")
        tokens = tokenizer.tokenize()
        self.assertEqual(len(tokens), 2)
        self.assertEqual(tokens[0].type, TokenType.TERM)
        self.assertEqual(tokens[0].value, "programming")
        self.assertEqual(tokens[1].type, TokenType.EOF)

    def test_multiple_terms(self):
        tokenizer = SearchQueryTokenizer("programming books streaming")
        tokens = tokenizer.tokenize()
        self.assertEqual(len(tokens), 4)
        self.assertEqual(tokens[0].type, TokenType.TERM)
        self.assertEqual(tokens[0].value, "programming")
        self.assertEqual(tokens[1].type, TokenType.TERM)
        self.assertEqual(tokens[1].value, "books")
        self.assertEqual(tokens[2].type, TokenType.TERM)
        self.assertEqual(tokens[2].value, "streaming")
        self.assertEqual(tokens[3].type, TokenType.EOF)

    def test_hyphenated_term(self):
        tokenizer = SearchQueryTokenizer("client-side")
        tokens = tokenizer.tokenize()
        self.assertEqual(len(tokens), 2)
        self.assertEqual(tokens[0].type, TokenType.TERM)
        self.assertEqual(tokens[0].value, "client-side")
        self.assertEqual(tokens[1].type, TokenType.EOF)

    def test_and_operator(self):
        tokenizer = SearchQueryTokenizer("programming and books")
        tokens = tokenizer.tokenize()
        self.assertEqual(len(tokens), 4)
        self.assertEqual(tokens[0].type, TokenType.TERM)
        self.assertEqual(tokens[0].value, "programming")
        self.assertEqual(tokens[1].type, TokenType.AND)
        self.assertEqual(tokens[1].value, "and")
        self.assertEqual(tokens[2].type, TokenType.TERM)
        self.assertEqual(tokens[2].value, "books")
        self.assertEqual(tokens[3].type, TokenType.EOF)

    def test_or_operator(self):
        tokenizer = SearchQueryTokenizer("programming or books")
        tokens = tokenizer.tokenize()
        self.assertEqual(len(tokens), 4)
        self.assertEqual(tokens[0].type, TokenType.TERM)
        self.assertEqual(tokens[0].value, "programming")
        self.assertEqual(tokens[1].type, TokenType.OR)
        self.assertEqual(tokens[1].value, "or")
        self.assertEqual(tokens[2].type, TokenType.TERM)
        self.assertEqual(tokens[2].value, "books")
        self.assertEqual(tokens[3].type, TokenType.EOF)

    def test_not_operator(self):
        tokenizer = SearchQueryTokenizer("programming not books")
        tokens = tokenizer.tokenize()
        self.assertEqual(len(tokens), 4)
        self.assertEqual(tokens[0].type, TokenType.TERM)
        self.assertEqual(tokens[0].value, "programming")
        self.assertEqual(tokens[1].type, TokenType.NOT)
        self.assertEqual(tokens[1].value, "not")
        self.assertEqual(tokens[2].type, TokenType.TERM)
        self.assertEqual(tokens[2].value, "books")
        self.assertEqual(tokens[3].type, TokenType.EOF)

    def test_case_insensitive_operators(self):
        tokenizer = SearchQueryTokenizer(
            "programming AND books OR streaming NOT videos"
        )
        tokens = tokenizer.tokenize()
        self.assertEqual(len(tokens), 8)
        self.assertEqual(tokens[1].type, TokenType.AND)
        self.assertEqual(tokens[3].type, TokenType.OR)
        self.assertEqual(tokens[5].type, TokenType.NOT)

    def test_parentheses(self):
        tokenizer = SearchQueryTokenizer("(programming or books) and streaming")
        tokens = tokenizer.tokenize()
        self.assertEqual(len(tokens), 8)
        self.assertEqual(tokens[0].type, TokenType.LPAREN)
        self.assertEqual(tokens[1].type, TokenType.TERM)
        self.assertEqual(tokens[1].value, "programming")
        self.assertEqual(tokens[2].type, TokenType.OR)
        self.assertEqual(tokens[3].type, TokenType.TERM)
        self.assertEqual(tokens[3].value, "books")
        self.assertEqual(tokens[4].type, TokenType.RPAREN)
        self.assertEqual(tokens[5].type, TokenType.AND)
        self.assertEqual(tokens[6].type, TokenType.TERM)
        self.assertEqual(tokens[6].value, "streaming")
        self.assertEqual(tokens[7].type, TokenType.EOF)

    def test_operator_as_part_of_term(self):
        # Terms containing operator words should be treated as terms
        tokenizer = SearchQueryTokenizer("android notarization")
        tokens = tokenizer.tokenize()
        self.assertEqual(len(tokens), 3)
        self.assertEqual(tokens[0].type, TokenType.TERM)
        self.assertEqual(tokens[0].value, "android")
        self.assertEqual(tokens[1].type, TokenType.TERM)
        self.assertEqual(tokens[1].value, "notarization")
        self.assertEqual(tokens[2].type, TokenType.EOF)

    def test_extra_whitespace(self):
        tokenizer = SearchQueryTokenizer("  programming   and    books  ")
        tokens = tokenizer.tokenize()
        self.assertEqual(len(tokens), 4)
        self.assertEqual(tokens[0].type, TokenType.TERM)
        self.assertEqual(tokens[0].value, "programming")
        self.assertEqual(tokens[1].type, TokenType.AND)
        self.assertEqual(tokens[2].type, TokenType.TERM)
        self.assertEqual(tokens[2].value, "books")
        self.assertEqual(tokens[3].type, TokenType.EOF)

    def test_quoted_strings(self):
        # Double quotes
        tokenizer = SearchQueryTokenizer('"good and bad"')
        tokens = tokenizer.tokenize()
        self.assertEqual(len(tokens), 2)
        self.assertEqual(tokens[0].type, TokenType.TERM)
        self.assertEqual(tokens[0].value, "good and bad")
        self.assertEqual(tokens[1].type, TokenType.EOF)

        # Single quotes
        tokenizer = SearchQueryTokenizer("'hello world'")
        tokens = tokenizer.tokenize()
        self.assertEqual(len(tokens), 2)
        self.assertEqual(tokens[0].type, TokenType.TERM)
        self.assertEqual(tokens[0].value, "hello world")
        self.assertEqual(tokens[1].type, TokenType.EOF)

    def test_quoted_strings_with_operators(self):
        tokenizer = SearchQueryTokenizer('"good and bad" or programming')
        tokens = tokenizer.tokenize()
        self.assertEqual(len(tokens), 4)
        self.assertEqual(tokens[0].type, TokenType.TERM)
        self.assertEqual(tokens[0].value, "good and bad")
        self.assertEqual(tokens[1].type, TokenType.OR)
        self.assertEqual(tokens[2].type, TokenType.TERM)
        self.assertEqual(tokens[2].value, "programming")
        self.assertEqual(tokens[3].type, TokenType.EOF)

    def test_escaped_quotes(self):
        # Escaped double quote within double quotes
        tokenizer = SearchQueryTokenizer('"say \\"hello\\""')
        tokens = tokenizer.tokenize()
        self.assertEqual(len(tokens), 2)
        self.assertEqual(tokens[0].type, TokenType.TERM)
        self.assertEqual(tokens[0].value, 'say "hello"')
        self.assertEqual(tokens[1].type, TokenType.EOF)

        # Escaped single quote within single quotes
        tokenizer = SearchQueryTokenizer("'don\\'t worry'")
        tokens = tokenizer.tokenize()
        self.assertEqual(len(tokens), 2)
        self.assertEqual(tokens[0].type, TokenType.TERM)
        self.assertEqual(tokens[0].value, "don't worry")
        self.assertEqual(tokens[1].type, TokenType.EOF)

    def test_unclosed_quotes(self):
        # Unclosed quote should be handled gracefully
        tokenizer = SearchQueryTokenizer('"unclosed quote')
        tokens = tokenizer.tokenize()
        self.assertEqual(len(tokens), 2)
        self.assertEqual(tokens[0].type, TokenType.TERM)
        self.assertEqual(tokens[0].value, "unclosed quote")
        self.assertEqual(tokens[1].type, TokenType.EOF)

    def test_tags(self):
        # Basic tag
        tokenizer = SearchQueryTokenizer("#python")
        tokens = tokenizer.tokenize()
        self.assertEqual(len(tokens), 2)
        self.assertEqual(tokens[0].type, TokenType.TAG)
        self.assertEqual(tokens[0].value, "python")
        self.assertEqual(tokens[1].type, TokenType.EOF)

        # Tag with hyphens
        tokenizer = SearchQueryTokenizer("#machine-learning")
        tokens = tokenizer.tokenize()
        self.assertEqual(len(tokens), 2)
        self.assertEqual(tokens[0].type, TokenType.TAG)
        self.assertEqual(tokens[0].value, "machine-learning")
        self.assertEqual(tokens[1].type, TokenType.EOF)

    def test_tags_with_operators(self):
        tokenizer = SearchQueryTokenizer("#python and #django")
        tokens = tokenizer.tokenize()
        self.assertEqual(len(tokens), 4)
        self.assertEqual(tokens[0].type, TokenType.TAG)
        self.assertEqual(tokens[0].value, "python")
        self.assertEqual(tokens[1].type, TokenType.AND)
        self.assertEqual(tokens[2].type, TokenType.TAG)
        self.assertEqual(tokens[2].value, "django")
        self.assertEqual(tokens[3].type, TokenType.EOF)

    def test_tags_mixed_with_terms(self):
        tokenizer = SearchQueryTokenizer("programming and #python and web")
        tokens = tokenizer.tokenize()
        self.assertEqual(len(tokens), 6)
        self.assertEqual(tokens[0].type, TokenType.TERM)
        self.assertEqual(tokens[0].value, "programming")
        self.assertEqual(tokens[1].type, TokenType.AND)
        self.assertEqual(tokens[2].type, TokenType.TAG)
        self.assertEqual(tokens[2].value, "python")
        self.assertEqual(tokens[3].type, TokenType.AND)
        self.assertEqual(tokens[4].type, TokenType.TERM)
        self.assertEqual(tokens[4].value, "web")
        self.assertEqual(tokens[5].type, TokenType.EOF)

    def test_empty_tag(self):
        # Tag with just # should be ignored (no token created)
        tokenizer = SearchQueryTokenizer("# ")
        tokens = tokenizer.tokenize()
        self.assertEqual(len(tokens), 1)
        self.assertEqual(tokens[0].type, TokenType.EOF)

        # Empty tag at end of string
        tokenizer = SearchQueryTokenizer("#")
        tokens = tokenizer.tokenize()
        self.assertEqual(len(tokens), 1)
        self.assertEqual(tokens[0].type, TokenType.EOF)

        # Empty tag mixed with other terms
        tokenizer = SearchQueryTokenizer("python # and django")
        tokens = tokenizer.tokenize()
        self.assertEqual(len(tokens), 4)
        self.assertEqual(tokens[0].type, TokenType.TERM)
        self.assertEqual(tokens[0].value, "python")
        self.assertEqual(tokens[1].type, TokenType.AND)
        self.assertEqual(tokens[2].type, TokenType.TERM)
        self.assertEqual(tokens[2].value, "django")
        self.assertEqual(tokens[3].type, TokenType.EOF)

    def test_special_keywords(self):
        tokenizer = SearchQueryTokenizer("!unread")
        tokens = tokenizer.tokenize()
        self.assertEqual(len(tokens), 2)
        self.assertEqual(tokens[0].type, TokenType.SPECIAL_KEYWORD)
        self.assertEqual(tokens[0].value, "unread")
        self.assertEqual(tokens[1].type, TokenType.EOF)

        tokenizer = SearchQueryTokenizer("!untagged")
        tokens = tokenizer.tokenize()
        self.assertEqual(len(tokens), 2)
        self.assertEqual(tokens[0].type, TokenType.SPECIAL_KEYWORD)
        self.assertEqual(tokens[0].value, "untagged")
        self.assertEqual(tokens[1].type, TokenType.EOF)

    def test_special_keywords_with_operators(self):
        tokenizer = SearchQueryTokenizer("!unread and !untagged")
        tokens = tokenizer.tokenize()
        self.assertEqual(len(tokens), 4)
        self.assertEqual(tokens[0].type, TokenType.SPECIAL_KEYWORD)
        self.assertEqual(tokens[0].value, "unread")
        self.assertEqual(tokens[1].type, TokenType.AND)
        self.assertEqual(tokens[2].type, TokenType.SPECIAL_KEYWORD)
        self.assertEqual(tokens[2].value, "untagged")
        self.assertEqual(tokens[3].type, TokenType.EOF)

    def test_special_keywords_mixed_with_terms_and_tags(self):
        tokenizer = SearchQueryTokenizer("!unread and #python and tutorial")
        tokens = tokenizer.tokenize()
        self.assertEqual(len(tokens), 6)
        self.assertEqual(tokens[0].type, TokenType.SPECIAL_KEYWORD)
        self.assertEqual(tokens[0].value, "unread")
        self.assertEqual(tokens[1].type, TokenType.AND)
        self.assertEqual(tokens[2].type, TokenType.TAG)
        self.assertEqual(tokens[2].value, "python")
        self.assertEqual(tokens[3].type, TokenType.AND)
        self.assertEqual(tokens[4].type, TokenType.TERM)
        self.assertEqual(tokens[4].value, "tutorial")
        self.assertEqual(tokens[5].type, TokenType.EOF)

    def test_empty_special_keyword(self):
        # Special keyword with just ! should be ignored (no token created)
        tokenizer = SearchQueryTokenizer("! ")
        tokens = tokenizer.tokenize()
        self.assertEqual(len(tokens), 1)
        self.assertEqual(tokens[0].type, TokenType.EOF)

        # Empty special keyword at end of string
        tokenizer = SearchQueryTokenizer("!")
        tokens = tokenizer.tokenize()
        self.assertEqual(len(tokens), 1)
        self.assertEqual(tokens[0].type, TokenType.EOF)


class SearchQueryParserTest(TestCase):
    """Test cases for the search query parser."""

    def test_empty_query(self):
        result = parse_search_query("")
        self.assertIsNone(result)

    def test_whitespace_only_query(self):
        result = parse_search_query("   ")
        self.assertIsNone(result)

    def test_single_term(self):
        result = parse_search_query("programming")
        expected = _term("programming")
        self.assertEqual(result, expected)

    def test_and_expression(self):
        result = parse_search_query("programming and books")
        expected = _and(_term("programming"), _term("books"))
        self.assertEqual(result, expected)

    def test_or_expression(self):
        result = parse_search_query("programming or books")
        expected = _or(_term("programming"), _term("books"))
        self.assertEqual(result, expected)

    def test_not_expression(self):
        result = parse_search_query("not programming")
        expected = _not(_term("programming"))
        self.assertEqual(result, expected)

    def test_operator_precedence_and_over_or(self):
        # "a or b and c" should parse as "a or (b and c)"
        result = parse_search_query("programming or books and streaming")
        expected = _or(_term("programming"), _and(_term("books"), _term("streaming")))
        self.assertEqual(result, expected)

    def test_operator_precedence_not_over_and(self):
        # "not a and b" should parse as "(not a) and b"
        result = parse_search_query("not programming and books")
        expected = _and(_not(_term("programming")), _term("books"))
        self.assertEqual(result, expected)

    def test_multiple_and_operators(self):
        # "a and b and c" should parse as "(a and b) and c" (left associative)
        result = parse_search_query("programming and books and streaming")
        expected = _and(_and(_term("programming"), _term("books")), _term("streaming"))
        self.assertEqual(result, expected)

    def test_multiple_or_operators(self):
        # "a or b or c" should parse as "(a or b) or c" (left associative)
        result = parse_search_query("programming or books or streaming")
        expected = _or(_or(_term("programming"), _term("books")), _term("streaming"))
        self.assertEqual(result, expected)

    def test_multiple_not_operators(self):
        result = parse_search_query("not not programming")
        expected = _not(_not(_term("programming")))
        self.assertEqual(result, expected)

    def test_parentheses_basic(self):
        result = parse_search_query("(programming)")
        expected = _term("programming")
        self.assertEqual(result, expected)

    def test_parentheses_change_precedence(self):
        # "(a or b) and c" should parse as "(a or b) and c"
        result = parse_search_query("(programming or books) and streaming")
        expected = _and(_or(_term("programming"), _term("books")), _term("streaming"))
        self.assertEqual(result, expected)

    def test_nested_parentheses(self):
        result = parse_search_query("((programming))")
        expected = _term("programming")
        self.assertEqual(result, expected)

    def test_complex_expression(self):
        result = parse_search_query(
            "programming and (books or streaming) and not client-side"
        )
        # Should be parsed as "(programming and (books or streaming)) and (not client-side)"
        expected = _and(
            _and(_term("programming"), _or(_term("books"), _term("streaming"))),
            _not(_term("client-side")),
        )
        self.assertEqual(result, expected)

    def test_hyphenated_terms(self):
        result = parse_search_query("client-side")
        expected = _term("client-side")
        self.assertEqual(result, expected)

    def test_case_insensitive_operators(self):
        result = parse_search_query("programming AND books OR streaming")
        expected = _or(_and(_term("programming"), _term("books")), _term("streaming"))
        self.assertEqual(result, expected)

        # Test implicit AND with NOT
        result = parse_search_query("programming AND books OR streaming NOT videos")
        expected = _or(
            _and(_term("programming"), _term("books")),
            _and(_term("streaming"), _not(_term("videos"))),
        )
        self.assertEqual(result, expected)

    def test_case_insensitive_operators_with_explicit_operators(self):
        result = parse_search_query("programming AND books OR streaming AND NOT videos")
        # Should parse as: (programming AND books) OR (streaming AND (NOT videos))
        expected = _or(
            _and(_term("programming"), _term("books")),
            _and(_term("streaming"), _not(_term("videos"))),
        )
        self.assertEqual(result, expected)

    def test_single_character_terms(self):
        result = parse_search_query("a and b")
        expected = _and(_term("a"), _term("b"))
        self.assertEqual(result, expected)

    def test_numeric_terms(self):
        result = parse_search_query("123 and 456")
        expected = _and(_term("123"), _term("456"))
        self.assertEqual(result, expected)

    def test_special_characters_in_terms(self):
        result = parse_search_query("test@example.com and file.txt")
        expected = _and(_term("test@example.com"), _term("file.txt"))
        self.assertEqual(result, expected)

    def test_url_terms(self):
        result = parse_search_query("https://example.com/foo/bar")
        expected = _term("https://example.com/foo/bar")
        self.assertEqual(result, expected)

    def test_url_with_operators(self):
        result = parse_search_query("https://github.com or https://gitlab.com")
        expected = _or(_term("https://github.com"), _term("https://gitlab.com"))
        self.assertEqual(result, expected)

    def test_quoted_strings(self):
        # Basic quoted string
        result = parse_search_query('"good and bad"')
        expected = _term("good and bad")
        self.assertEqual(result, expected)

        # Single quotes
        result = parse_search_query("'hello world'")
        expected = _term("hello world")
        self.assertEqual(result, expected)

    def test_quoted_strings_with_operators(self):
        # Quoted string with OR
        result = parse_search_query('"good and bad" or programming')
        expected = _or(_term("good and bad"), _term("programming"))
        self.assertEqual(result, expected)

        # Quoted string with AND
        result = parse_search_query('documentation and "API reference"')
        expected = _and(_term("documentation"), _term("API reference"))
        self.assertEqual(result, expected)

        # Quoted string with NOT
        result = parse_search_query('programming and not "bad practices"')
        expected = _and(_term("programming"), _not(_term("bad practices")))
        self.assertEqual(result, expected)

    def test_multiple_quoted_strings(self):
        result = parse_search_query('"hello world" and "goodbye moon"')
        expected = _and(_term("hello world"), _term("goodbye moon"))
        self.assertEqual(result, expected)

    def test_quoted_strings_with_parentheses(self):
        result = parse_search_query('("good morning" or "good evening") and coffee')
        expected = _and(
            _or(_term("good morning"), _term("good evening")), _term("coffee")
        )
        self.assertEqual(result, expected)

    def test_escaped_quotes_in_terms(self):
        result = parse_search_query('"say \\"hello\\""')
        expected = _term('say "hello"')
        self.assertEqual(result, expected)

    def test_tags(self):
        # Basic tag
        result = parse_search_query("#python")
        expected = _tag("python")
        self.assertEqual(result, expected)

        # Tag with hyphens
        result = parse_search_query("#machine-learning")
        expected = _tag("machine-learning")
        self.assertEqual(result, expected)

    def test_tags_with_operators(self):
        # Tag with AND
        result = parse_search_query("#python and #django")
        expected = _and(_tag("python"), _tag("django"))
        self.assertEqual(result, expected)

        # Tag with OR
        result = parse_search_query("#frontend or #backend")
        expected = _or(_tag("frontend"), _tag("backend"))
        self.assertEqual(result, expected)

        # Tag with NOT
        result = parse_search_query("not #deprecated")
        expected = _not(_tag("deprecated"))
        self.assertEqual(result, expected)

    def test_tags_mixed_with_terms(self):
        result = parse_search_query("programming and #python and tutorial")
        expected = _and(_and(_term("programming"), _tag("python")), _term("tutorial"))
        self.assertEqual(result, expected)

    def test_tags_with_quoted_strings(self):
        result = parse_search_query('"machine learning" and #python')
        expected = _and(_term("machine learning"), _tag("python"))
        self.assertEqual(result, expected)

    def test_tags_with_parentheses(self):
        result = parse_search_query("(#frontend or #backend) and javascript")
        expected = _and(_or(_tag("frontend"), _tag("backend")), _term("javascript"))
        self.assertEqual(result, expected)

    def test_empty_tags_ignored(self):
        # Test single empty tag
        result = parse_search_query("#")
        expected = None  # Empty query
        self.assertEqual(result, expected)

        # Test query that's just an empty tag and whitespace
        result = parse_search_query("# ")
        expected = None  # Empty query
        self.assertEqual(result, expected)

    def test_special_keywords(self):
        result = parse_search_query("!unread")
        expected = _keyword("unread")
        self.assertEqual(result, expected)

        result = parse_search_query("!untagged")
        expected = _keyword("untagged")
        self.assertEqual(result, expected)

    def test_special_keywords_with_operators(self):
        # Special keyword with AND
        result = parse_search_query("!unread and !untagged")
        expected = _and(_keyword("unread"), _keyword("untagged"))
        self.assertEqual(result, expected)

        # Special keyword with OR
        result = parse_search_query("!unread or !untagged")
        expected = _or(_keyword("unread"), _keyword("untagged"))
        self.assertEqual(result, expected)

        # Special keyword with NOT
        result = parse_search_query("not !unread")
        expected = _not(_keyword("unread"))
        self.assertEqual(result, expected)

    def test_special_keywords_mixed_with_terms_and_tags(self):
        result = parse_search_query("!unread and #python and tutorial")
        expected = _and(_and(_keyword("unread"), _tag("python")), _term("tutorial"))
        self.assertEqual(result, expected)

    def test_special_keywords_with_quoted_strings(self):
        result = parse_search_query('"machine learning" and !unread')
        expected = _and(_term("machine learning"), _keyword("unread"))
        self.assertEqual(result, expected)

    def test_special_keywords_with_parentheses(self):
        result = parse_search_query("(!unread or !untagged) and javascript")
        expected = _and(
            _or(_keyword("unread"), _keyword("untagged")), _term("javascript")
        )
        self.assertEqual(result, expected)

    def test_special_keywords_within_quoted_string(self):
        result = parse_search_query("'!unread and !untagged'")
        expected = _term("!unread and !untagged")
        self.assertEqual(result, expected)

    def test_implicit_and_basic(self):
        # Basic implicit AND between terms
        result = parse_search_query("programming book")
        expected = _and(_term("programming"), _term("book"))
        self.assertEqual(result, expected)

        # Three terms with implicit AND
        result = parse_search_query("python machine learning")
        expected = _and(_and(_term("python"), _term("machine")), _term("learning"))
        self.assertEqual(result, expected)

    def test_implicit_and_with_tags(self):
        # Implicit AND between term and tag
        result = parse_search_query("tutorial #python")
        expected = _and(_term("tutorial"), _tag("python"))
        self.assertEqual(result, expected)

        # Implicit AND between tag and term
        result = parse_search_query("#javascript tutorial")
        expected = _and(_tag("javascript"), _term("tutorial"))
        self.assertEqual(result, expected)

        # Multiple tags with implicit AND
        result = parse_search_query("#python #django #tutorial")
        expected = _and(_and(_tag("python"), _tag("django")), _tag("tutorial"))
        self.assertEqual(result, expected)

    def test_implicit_and_with_quoted_strings(self):
        # Implicit AND with quoted strings
        result = parse_search_query('"machine learning" tutorial')
        expected = _and(_term("machine learning"), _term("tutorial"))
        self.assertEqual(result, expected)

        # Mixed types with implicit AND
        result = parse_search_query('"deep learning" #python tutorial')
        expected = _and(_and(_term("deep learning"), _tag("python")), _term("tutorial"))
        self.assertEqual(result, expected)

    def test_implicit_and_with_explicit_operators(self):
        # Mixed implicit and explicit AND
        result = parse_search_query("python tutorial and django")
        expected = _and(_and(_term("python"), _term("tutorial")), _term("django"))
        self.assertEqual(result, expected)

        # Implicit AND with OR
        result = parse_search_query("python tutorial or java guide")
        expected = _or(
            _and(_term("python"), _term("tutorial")),
            _and(_term("java"), _term("guide")),
        )
        self.assertEqual(result, expected)

    def test_implicit_and_with_not(self):
        # NOT with implicit AND
        result = parse_search_query("not deprecated tutorial")
        expected = _and(_not(_term("deprecated")), _term("tutorial"))
        self.assertEqual(result, expected)

        # Implicit AND with NOT at end
        result = parse_search_query("python tutorial not deprecated")
        expected = _and(
            _and(_term("python"), _term("tutorial")), _not(_term("deprecated"))
        )
        self.assertEqual(result, expected)

    def test_implicit_and_with_parentheses(self):
        # Parentheses with implicit AND
        result = parse_search_query("(python tutorial) or java")
        expected = _or(_and(_term("python"), _term("tutorial")), _term("java"))
        self.assertEqual(result, expected)

        # Complex parentheses with implicit AND
        result = parse_search_query(
            "(machine learning #python) and (web development #javascript)"
        )
        expected = _and(
            _and(_and(_term("machine"), _term("learning")), _tag("python")),
            _and(_and(_term("web"), _term("development")), _tag("javascript")),
        )
        self.assertEqual(result, expected)

    def test_complex_precedence_with_implicit_and(self):
        result = parse_search_query("python tutorial or javascript guide")
        expected = _or(
            _and(_term("python"), _term("tutorial")),
            _and(_term("javascript"), _term("guide")),
        )
        self.assertEqual(result, expected)

        result = parse_search_query(
            "machine learning and (python or r) tutorial #beginner"
        )
        expected = _and(
            _and(
                _and(
                    _and(_term("machine"), _term("learning")),
                    _or(_term("python"), _term("r")),
                ),
                _term("tutorial"),
            ),
            _tag("beginner"),
        )
        self.assertEqual(result, expected)

    def test_operator_words_as_substrings(self):
        # Terms that contain operator words as substrings should be treated as terms
        result = parse_search_query("android and notification")
        expected = _and(_term("android"), _term("notification"))
        self.assertEqual(result, expected)

    def test_complex_queries(self):
        test_cases = [
            (
                "(programming or software) and not client-side and (javascript or python)",
                _and(
                    _and(
                        _or(_term("programming"), _term("software")),
                        _not(_term("client-side")),
                    ),
                    _or(_term("javascript"), _term("python")),
                ),
            ),
            (
                "(machine-learning or ai) and python and not deprecated",
                _and(
                    _and(
                        _or(_term("machine-learning"), _term("ai")),
                        _term("python"),
                    ),
                    _not(_term("deprecated")),
                ),
            ),
            (
                "frontend and (react or vue or angular) and not jquery",
                _and(
                    _and(
                        _term("frontend"),
                        _or(
                            _or(_term("react"), _term("vue")),
                            _term("angular"),
                        ),
                    ),
                    _not(_term("jquery")),
                ),
            ),
            (
                '"machine learning" and (python or r) and not "deep learning"',
                _and(
                    _and(
                        _term("machine learning"),
                        _or(_term("python"), _term("r")),
                    ),
                    _not(_term("deep learning")),
                ),
            ),
            (
                "(#python or #javascript) and tutorial and not #deprecated",
                _and(
                    _and(
                        _or(_tag("python"), _tag("javascript")),
                        _term("tutorial"),
                    ),
                    _not(_tag("deprecated")),
                ),
            ),
            (
                "machine learning tutorial #python beginner",
                _and(
                    _and(
                        _and(
                            _and(_term("machine"), _term("learning")), _term("tutorial")
                        ),
                        _tag("python"),
                    ),
                    _term("beginner"),
                ),
            ),
        ]

        for query, expected_ast in test_cases:
            with self.subTest(query=query):
                result = parse_search_query(query)
                self.assertEqual(result, expected_ast, f"Failed for query: {query}")


class SearchQueryParserErrorTest(TestCase):
    def test_unmatched_left_parenthesis(self):
        with self.assertRaises(SearchQueryParseError) as cm:
            parse_search_query("(programming and books")
        self.assertIn("Expected RPAREN", str(cm.exception))

    def test_unmatched_right_parenthesis(self):
        with self.assertRaises(SearchQueryParseError) as cm:
            parse_search_query("programming and books)")
        self.assertIn("Unexpected token", str(cm.exception))

    def test_empty_parentheses(self):
        with self.assertRaises(SearchQueryParseError) as cm:
            parse_search_query("()")
        self.assertIn("Unexpected token RPAREN", str(cm.exception))

    def test_operator_without_operand(self):
        with self.assertRaises(SearchQueryParseError) as cm:
            parse_search_query("and")
        self.assertIn("Unexpected token AND", str(cm.exception))

    def test_trailing_operator(self):
        with self.assertRaises(SearchQueryParseError) as cm:
            parse_search_query("programming and")
        self.assertIn("Unexpected token EOF", str(cm.exception))

    def test_consecutive_operators(self):
        with self.assertRaises(SearchQueryParseError) as cm:
            parse_search_query("programming and or books")
        self.assertIn("Unexpected token OR", str(cm.exception))

    def test_not_without_operand(self):
        with self.assertRaises(SearchQueryParseError) as cm:
            parse_search_query("not")
        self.assertIn("Unexpected token EOF", str(cm.exception))


class ExpressionToStringTest(TestCase):
    def test_simple_term(self):
        expr = _term("python")
        self.assertEqual(expression_to_string(expr), "python")

    def test_simple_tag(self):
        expr = _tag("python")
        self.assertEqual(expression_to_string(expr), "#python")

    def test_simple_keyword(self):
        expr = _keyword("unread")
        self.assertEqual(expression_to_string(expr), "!unread")

    def test_term_with_spaces(self):
        expr = _term("machine learning")
        self.assertEqual(expression_to_string(expr), '"machine learning"')

    def test_term_with_quotes(self):
        expr = _term('say "hello"')
        self.assertEqual(expression_to_string(expr), '"say \\"hello\\""')

    def test_and_expression_implicit(self):
        expr = _and(_term("python"), _term("tutorial"))
        self.assertEqual(expression_to_string(expr), "python tutorial")

    def test_and_expression_with_tags(self):
        expr = _and(_tag("python"), _tag("django"))
        self.assertEqual(expression_to_string(expr), "#python #django")

    def test_and_expression_complex(self):
        expr = _and(_or(_term("python"), _term("ruby")), _term("tutorial"))
        self.assertEqual(expression_to_string(expr), "(python or ruby) tutorial")

    def test_or_expression(self):
        expr = _or(_term("python"), _term("ruby"))
        self.assertEqual(expression_to_string(expr), "python or ruby")

    def test_or_expression_with_and(self):
        expr = _or(_and(_term("python"), _term("tutorial")), _term("ruby"))
        self.assertEqual(expression_to_string(expr), "python tutorial or ruby")

    def test_not_expression(self):
        expr = _not(_term("deprecated"))
        self.assertEqual(expression_to_string(expr), "not deprecated")

    def test_not_with_tag(self):
        expr = _not(_tag("deprecated"))
        self.assertEqual(expression_to_string(expr), "not #deprecated")

    def test_not_with_and(self):
        expr = _not(_and(_term("python"), _term("deprecated")))
        self.assertEqual(expression_to_string(expr), "not (python deprecated)")

    def test_complex_nested_expression(self):
        expr = _and(
            _or(_term("python"), _term("ruby")),
            _or(_term("tutorial"), _term("guide")),
        )
        result = expression_to_string(expr)
        self.assertEqual(result, "(python or ruby) (tutorial or guide)")

    def test_implicit_and_chain(self):
        expr = _and(_and(_term("machine"), _term("learning")), _term("tutorial"))
        self.assertEqual(expression_to_string(expr), "machine learning tutorial")

    def test_none_expression(self):
        self.assertEqual(expression_to_string(None), "")

    def test_round_trip(self):
        test_cases = [
            "#python",
            "python tutorial",
            "#python #django",
            "python or ruby",
            "not deprecated",
            "(python or ruby) and tutorial",
            "tutorial and (python or ruby)",
            "(python or ruby) tutorial",
            "tutorial (python or ruby)",
        ]

        for query in test_cases:
            with self.subTest(query=query):
                ast = parse_search_query(query)
                result = expression_to_string(ast)
                ast2 = parse_search_query(result)
                self.assertEqual(ast, ast2)


class StripTagFromQueryTest(TestCase):
    def test_single_tag(self):
        result = strip_tag_from_query("#books", "books")
        self.assertEqual(result, "")

    def test_tag_with_and(self):
        result = strip_tag_from_query("#history and #books", "books")
        self.assertEqual(result, "#history")

    def test_tag_with_and_not(self):
        result = strip_tag_from_query("#history and not #books", "books")
        self.assertEqual(result, "#history")

    def test_implicit_and_with_term_and_tags(self):
        result = strip_tag_from_query("roman #history #books", "books")
        self.assertEqual(result, "roman #history")

    def test_tag_in_or_expression(self):
        result = strip_tag_from_query("roman and (#history or #books)", "books")
        self.assertEqual(result, "roman #history")

    def test_complex_or_with_and(self):
        result = strip_tag_from_query(
            "(roman and #books) or (greek and #books)", "books"
        )
        self.assertEqual(result, "roman or greek")

    def test_case_insensitive(self):
        result = strip_tag_from_query("#Books and #History", "books")
        self.assertEqual(result, "#History")

    def test_tag_not_present(self):
        result = strip_tag_from_query("#history and #science", "books")
        self.assertEqual(result, "#history #science")

    def test_multiple_same_tags(self):
        result = strip_tag_from_query("#books or #books", "books")
        self.assertEqual(result, "")

    def test_nested_parentheses(self):
        result = strip_tag_from_query("((#books and tutorial) or guide)", "books")
        self.assertEqual(result, "tutorial or guide")

    def test_not_expression_with_tag(self):
        result = strip_tag_from_query("tutorial and not #books", "books")
        self.assertEqual(result, "tutorial")

    def test_only_not_tag(self):
        result = strip_tag_from_query("not #books", "books")
        self.assertEqual(result, "")

    def test_complex_query(self):
        result = strip_tag_from_query(
            "(#python or #ruby) and tutorial and not #books", "books"
        )
        self.assertEqual(result, "(#python or #ruby) tutorial")

    def test_empty_query(self):
        result = strip_tag_from_query("", "books")
        self.assertEqual(result, "")

    def test_whitespace_only(self):
        result = strip_tag_from_query("   ", "books")
        self.assertEqual(result, "")

    def test_special_keywords_preserved(self):
        result = strip_tag_from_query("!unread and #books", "books")
        self.assertEqual(result, "!unread")

    def test_quoted_terms_preserved(self):
        result = strip_tag_from_query('"machine learning" and #books', "books")
        self.assertEqual(result, '"machine learning"')

    def test_all_tags_in_and_chain(self):
        result = strip_tag_from_query("#books and #books and #books", "books")
        self.assertEqual(result, "")

    def test_tag_similar_name(self):
        # Should not remove #book when removing #books
        result = strip_tag_from_query("#book and #books", "books")
        self.assertEqual(result, "#book")

    def test_invalid_query_returns_original(self):
        # If query is malformed, should return original
        result = strip_tag_from_query("(unclosed paren", "books")
        self.assertEqual(result, "(unclosed paren")

    def test_implicit_and_in_output(self):
        result = strip_tag_from_query("python tutorial #books #django", "books")
        self.assertEqual(result, "python tutorial #django")

    def test_nested_or_simplify_parenthesis(self):
        result = strip_tag_from_query(
            "(#books or tutorial) and (#books or guide)", "books"
        )
        self.assertEqual(result, "tutorial guide")

    def test_nested_or_preserve_parenthesis(self):
        result = strip_tag_from_query(
            "(#books or tutorial or guide) and (#books or help or lesson)", "books"
        )
        self.assertEqual(result, "(tutorial or guide) (help or lesson)")

    def test_left_side_removed(self):
        result = strip_tag_from_query("#books and python", "books")
        self.assertEqual(result, "python")

    def test_right_side_removed(self):
        result = strip_tag_from_query("python and #books", "books")
        self.assertEqual(result, "python")


class StripTagFromQueryLaxSearchTest(TestCase):
    def setUp(self):
        self.lax_profile = type(
            "UserProfile", (), {"tag_search": UserProfile.TAG_SEARCH_LAX}
        )()
        self.strict_profile = type(
            "UserProfile", (), {"tag_search": UserProfile.TAG_SEARCH_STRICT}
        )()

    def test_lax_search_removes_matching_term(self):
        result = strip_tag_from_query("books", "books", self.lax_profile)
        self.assertEqual(result, "")

    def test_lax_search_removes_term_case_insensitive(self):
        result = strip_tag_from_query("Books", "books", self.lax_profile)
        self.assertEqual(result, "")

        result = strip_tag_from_query("BOOKS", "books", self.lax_profile)
        self.assertEqual(result, "")

    def test_lax_search_multiple_terms(self):
        result = strip_tag_from_query("books and history", "books", self.lax_profile)
        self.assertEqual(result, "history")

    def test_lax_search_preserves_non_matching_terms(self):
        result = strip_tag_from_query("history and science", "books", self.lax_profile)
        self.assertEqual(result, "history science")

    def test_lax_search_removes_both_tag_and_term(self):
        result = strip_tag_from_query("books #books", "books", self.lax_profile)
        self.assertEqual(result, "")

    def test_lax_search_mixed_tag_and_term(self):
        result = strip_tag_from_query(
            "books and #history and #books", "books", self.lax_profile
        )
        self.assertEqual(result, "#history")

    def test_lax_search_term_in_or_expression(self):
        result = strip_tag_from_query(
            "(books or history) and guide", "books", self.lax_profile
        )
        self.assertEqual(result, "history guide")

    def test_lax_search_term_in_not_expression(self):
        result = strip_tag_from_query(
            "history and not books", "books", self.lax_profile
        )
        self.assertEqual(result, "history")

    def test_lax_search_only_not_term(self):
        result = strip_tag_from_query("not books", "books", self.lax_profile)
        self.assertEqual(result, "")

    def test_lax_search_complex_query(self):
        result = strip_tag_from_query(
            "(books or #books) and (history or guide)", "books", self.lax_profile
        )
        self.assertEqual(result, "history or guide")

    def test_lax_search_quoted_term_with_same_name(self):
        result = strip_tag_from_query('"books" and history', "books", self.lax_profile)
        self.assertEqual(result, "history")

    def test_lax_search_partial_match_not_removed(self):
        result = strip_tag_from_query("bookshelf", "books", self.lax_profile)
        self.assertEqual(result, "bookshelf")

    def test_lax_search_multiple_occurrences(self):
        result = strip_tag_from_query(
            "books or books or history", "books", self.lax_profile
        )
        self.assertEqual(result, "history")

    def test_lax_search_nested_expressions(self):
        result = strip_tag_from_query(
            "((books and tutorial) or guide) and history", "books", self.lax_profile
        )
        self.assertEqual(result, "(tutorial or guide) history")

    def test_strict_search_preserves_terms(self):
        result = strip_tag_from_query("books", "books", self.strict_profile)
        self.assertEqual(result, "books")

    def test_strict_search_preserves_terms_with_tags(self):
        result = strip_tag_from_query("books #books", "books", self.strict_profile)
        self.assertEqual(result, "books")

    def test_no_profile_defaults_to_strict(self):
        result = strip_tag_from_query("books #books", "books", None)
        self.assertEqual(result, "books")


class ExtractTagNamesFromQueryTest(TestCase):
    def test_empty_query(self):
        result = extract_tag_names_from_query("")
        self.assertEqual(result, [])

    def test_whitespace_query(self):
        result = extract_tag_names_from_query("   ")
        self.assertEqual(result, [])

    def test_single_tag(self):
        result = extract_tag_names_from_query("#python")
        self.assertEqual(result, ["python"])

    def test_multiple_tags(self):
        result = extract_tag_names_from_query("#python and #django")
        self.assertEqual(result, ["django", "python"])

    def test_tags_with_or(self):
        result = extract_tag_names_from_query("#python or #ruby")
        self.assertEqual(result, ["python", "ruby"])

    def test_tags_with_not(self):
        result = extract_tag_names_from_query("not #deprecated")
        self.assertEqual(result, ["deprecated"])

    def test_tags_in_complex_query(self):
        result = extract_tag_names_from_query(
            "(#python or #ruby) and #tutorial and not #deprecated"
        )
        self.assertEqual(result, ["deprecated", "python", "ruby", "tutorial"])

    def test_duplicate_tags(self):
        result = extract_tag_names_from_query("#python and #python")
        self.assertEqual(result, ["python"])

    def test_case_insensitive_deduplication(self):
        result = extract_tag_names_from_query("#Python and #PYTHON and #python")
        self.assertEqual(result, ["python"])

    def test_mixed_tags_and_terms(self):
        result = extract_tag_names_from_query("tutorial #python guide #django")
        self.assertEqual(result, ["django", "python"])

    def test_only_terms_no_tags(self):
        result = extract_tag_names_from_query("tutorial guide")
        self.assertEqual(result, [])

    def test_special_keywords_not_extracted(self):
        result = extract_tag_names_from_query("!unread and #python")
        self.assertEqual(result, ["python"])

    def test_tags_in_nested_parentheses(self):
        result = extract_tag_names_from_query("((#python and #django) or #ruby)")
        self.assertEqual(result, ["django", "python", "ruby"])

    def test_invalid_query_returns_empty(self):
        result = extract_tag_names_from_query("(unclosed paren")
        self.assertEqual(result, [])

    def test_tags_with_hyphens(self):
        result = extract_tag_names_from_query("#machine-learning and #deep-learning")
        self.assertEqual(result, ["deep-learning", "machine-learning"])


class ExtractTagNamesFromQueryLaxSearchTest(TestCase):
    def setUp(self):
        self.lax_profile = type(
            "UserProfile", (), {"tag_search": UserProfile.TAG_SEARCH_LAX}
        )()
        self.strict_profile = type(
            "UserProfile", (), {"tag_search": UserProfile.TAG_SEARCH_STRICT}
        )()

    def test_lax_search_extracts_terms(self):
        result = extract_tag_names_from_query("python and django", self.lax_profile)
        self.assertEqual(result, ["django", "python"])

    def test_lax_search_mixed_tags_and_terms(self):
        result = extract_tag_names_from_query(
            "tutorial #python guide #django", self.lax_profile
        )
        self.assertEqual(result, ["django", "guide", "python", "tutorial"])

    def test_lax_search_deduplicates_tags_and_terms(self):
        result = extract_tag_names_from_query("python #python", self.lax_profile)
        self.assertEqual(result, ["python"])

    def test_lax_search_case_insensitive_dedup(self):
        result = extract_tag_names_from_query("Python #python PYTHON", self.lax_profile)
        self.assertEqual(result, ["python"])

    def test_lax_search_terms_in_or_expression(self):
        result = extract_tag_names_from_query(
            "(python or ruby) and tutorial", self.lax_profile
        )
        self.assertEqual(result, ["python", "ruby", "tutorial"])

    def test_lax_search_terms_in_not_expression(self):
        result = extract_tag_names_from_query(
            "tutorial and not deprecated", self.lax_profile
        )
        self.assertEqual(result, ["deprecated", "tutorial"])

    def test_lax_search_quoted_terms(self):
        result = extract_tag_names_from_query(
            '"machine learning" and #python', self.lax_profile
        )
        self.assertEqual(result, ["machine learning", "python"])

    def test_lax_search_complex_query(self):
        result = extract_tag_names_from_query(
            "(python or #ruby) and tutorial and not #deprecated", self.lax_profile
        )
        self.assertEqual(result, ["deprecated", "python", "ruby", "tutorial"])

    def test_lax_search_special_keywords_not_extracted(self):
        result = extract_tag_names_from_query(
            "!unread and python and #django", self.lax_profile
        )
        self.assertEqual(result, ["django", "python"])

    def test_strict_search_ignores_terms(self):
        result = extract_tag_names_from_query("python and django", self.strict_profile)
        self.assertEqual(result, [])

    def test_strict_search_only_tags(self):
        result = extract_tag_names_from_query(
            "tutorial #python guide #django", self.strict_profile
        )
        self.assertEqual(result, ["django", "python"])

    def test_no_profile_defaults_to_strict(self):
        result = extract_tag_names_from_query("python #django", None)
        self.assertEqual(result, ["django"])


================================================
FILE: bookmarks/tests/test_settings_export_view.py
================================================
import datetime
from unittest.mock import patch

from django.test import TestCase
from django.urls import reverse

from bookmarks.models import Bookmark
from bookmarks.tests.helpers import BookmarkFactoryMixin


class SettingsExportViewTestCase(TestCase, BookmarkFactoryMixin):
    def setUp(self) -> None:
        user = self.get_or_create_test_user()
        self.client.force_login(user)

    def assertFormErrorHint(self, response, text: str):
        self.assertContains(response, '<div class="has-error">')
        self.assertContains(response, text)

    def test_should_export_successfully(self):
        self.setup_bookmark(tags=[self.setup_tag()])
        self.setup_bookmark(tags=[self.setup_tag()])
        self.setup_bookmark(tags=[self.setup_tag()])
        self.setup_bookmark(tags=[self.setup_tag()], is_archived=True)
        self.setup_bookmark(tags=[self.setup_tag()], is_archived=True)
        self.setup_bookmark(tags=[self.setup_tag()], is_archived=True)

        response = self.client.get(reverse("linkding:settings.export"), follow=True)

        self.assertEqual(response.status_code, 200)
        self.assertEqual(response["content-type"], "text/plain; charset=UTF-8")

        for bookmark in Bookmark.objects.all():
            self.assertContains(response, bookmark.url)

    def test_should_only_export_user_bookmarks(self):
        other_user = self.setup_user()
        owned_bookmarks = [
            self.setup_bookmark(tags=[self.setup_tag()]),
            self.setup_bookmark(tags=[self.setup_tag()]),
            self.setup_bookmark(tags=[self.setup_tag()]),
        ]
        non_owned_bookmarks = [
            self.setup_bookmark(tags=[self.setup_tag()], user=other_user),
            self.setup_bookmark(tags=[self.setup_tag()], user=other_user),
            self.setup_bookmark(tags=[self.setup_tag()], user=other_user),
        ]

        response = self.client.get(reverse("linkding:settings.export"), follow=True)

        text = response.content.decode("utf-8")

        for bookmark in owned_bookmarks:
            self.assertIn(bookmark.url, text)

        for bookmark in non_owned_bookmarks:
            self.assertNotIn(bookmark.url, text)

    def test_should_check_authentication(self):
        self.client.logout()
        response = self.client.get(reverse("linkding:settings.export"), follow=True)

        self.assertRedirects(
            response, reverse("login") + "?next=" + reverse("linkding:settings.export")
        )

    def test_should_show_hint_when_export_raises_error(self):
        with patch(
            "bookmarks.services.exporter.export_netscape_html"
        ) as mock_export_netscape_html:
            mock_export_netscape_html.side_effect = Exception("Nope")
            response = self.client.get(reverse("linkding:settings.export"), follow=True)

            self.assertTemplateUsed(response, "settings/general.html")
            self.assertFormErrorHint(
                response, "An error occurred during bookmark export."
            )

    def test_filename_includes_date_and_time(self):
        self.setup_bookmark()

        # Mock timezone.now to return a fixed datetime for predictable filename
        fixed_time = datetime.datetime(2023, 5, 15, 14, 30, 45, tzinfo=datetime.UTC)

        with patch("bookmarks.views.settings.timezone.now", return_value=fixed_time):
            response = self.client.get(reverse("linkding:settings.export"), follow=True)

        self.assertEqual(response.status_code, 200)
        expected_filename = 'attachment; filename="bookmarks_2023-05-15_14-30-45.html"'
        self.assertEqual(response["Content-Disposition"], expected_filename)


================================================
FILE: bookmarks/tests/test_settings_general_view.py
================================================
import hashlib
import random
from unittest.mock import Mock, patch

import requests
from django.test import TestCase, override_settings
from django.urls import reverse
from requests import RequestException

from bookmarks.models import GlobalSettings, UserProfile
from bookmarks.services import tasks
from bookmarks.tests.helpers import BookmarkFactoryMixin
from bookmarks.views.settings import app_version, get_version_info


class SettingsGeneralViewTestCase(TestCase, BookmarkFactoryMixin):
    def setUp(self) -> None:
        user = self.get_or_create_test_user()
        self.client.force_login(user)

    def create_profile_form_data(self, overrides=None):
        if not overrides:
            overrides = {}
        form_data = {
            "update_profile": "",
            "theme": UserProfile.THEME_AUTO,
            "bookmark_date_display": UserProfile.BOOKMARK_DATE_DISPLAY_RELATIVE,
            "bookmark_description_display": UserProfile.BOOKMARK_DESCRIPTION_DISPLAY_INLINE,
            "bookmark_description_max_lines": 1,
            "bookmark_link_target": UserProfile.BOOKMARK_LINK_TARGET_BLANK,
            "web_archive_integration": UserProfile.WEB_ARCHIVE_INTEGRATION_DISABLED,
            "enable_sharing": False,
            "enable_public_sharing": False,
            "enable_favicons": False,
            "enable_preview_images": False,
            "enable_automatic_html_snapshots": True,
            "tag_search": UserProfile.TAG_SEARCH_STRICT,
            "tag_grouping": UserProfile.TAG_GROUPING_ALPHABETICAL,
            "display_url": False,
            "display_view_bookmark_action": True,
            "display_edit_bookmark_action": True,
            "display_archive_bookmark_action": True,
            "display_remove_bookmark_action": True,
            "permanent_notes": False,
            "custom_css": "",
            "auto_tagging_rules": "",
            "items_per_page": "30",
            "sticky_pagination": False,
            "collapse_side_panel": False,
            "hide_bundles": False,
            "legacy_search": False,
        }

        return {**form_data, **overrides}

    def assertSuccessMessage(self, html, message: str, count=1):
        self.assertInHTML(
            f"""
            <div class="toast toast-success mb-4">{message}</div>
        """,
            html,
            count=count,
        )

    def assertErrorMessage(self, html, message: str, count=1):
        self.assertInHTML(
            f"""
            <div class="toast toast-error mb-4">{message}</div>
        """,
            html,
            count=count,
        )

    def test_should_render_successfully(self):
        response = self.client.get(reverse("linkding:settings.general"))

        self.assertEqual(response.status_code, 200)

    def test_should_check_authentication(self):
        self.client.logout()
        response = self.client.get(reverse("linkding:settings.general"), follow=True)

        self.assertRedirects(
            response,
            reverse("login") + "?next=" + reverse("linkding:settings.general"),
        )

        response = self.client.get(reverse("linkding:settings.update"), follow=True)

        self.assertRedirects(
            response,
            reverse("login") + "?next=" + reverse("linkding:settings.update"),
        )

    def test_update_profile(self):
        form_data = {
            "update_profile": "",
            "theme": UserProfile.THEME_DARK,
            "bookmark_date_display": UserProfile.BOOKMARK_DATE_DISPLAY_HIDDEN,
            "bookmark_description_display": UserProfile.BOOKMARK_DESCRIPTION_DISPLAY_SEPARATE,
            "bookmark_description_max_lines": 3,
            "bookmark_link_target": UserProfile.BOOKMARK_LINK_TARGET_SELF,
            "web_archive_integration": UserProfile.WEB_ARCHIVE_INTEGRATION_ENABLED,
            "enable_sharing": True,
            "enable_public_sharing": True,
            "enable_favicons": True,
            "enable_preview_images": True,
            "enable_automatic_html_snapshots": False,
            "tag_search": UserProfile.TAG_SEARCH_LAX,
            "tag_grouping": UserProfile.TAG_GROUPING_DISABLED,
            "display_url": True,
            "display_view_bookmark_action": False,
            "display_edit_bookmark_action": False,
            "display_archive_bookmark_action": False,
            "display_remove_bookmark_action": False,
            "permanent_notes": True,
            "default_mark_unread": True,
            "default_mark_shared": True,
            "custom_css": "body { background-color: #000; }",
            "auto_tagging_rules": "example.com tag",
            "items_per_page": "10",
            "sticky_pagination": True,
            "collapse_side_panel": True,
            "hide_bundles": True,
            "legacy_search": True,
        }
        response = self.client.post(
            reverse("linkding:settings.update"), form_data, follow=True
        )
        html = response.content.decode()

        self.user.profile.refresh_from_db()

        self.assertEqual(response.status_code, 200)
        self.assertEqual(self.user.profile.theme, form_data["theme"])
        self.assertEqual(
            self.user.profile.bookmark_date_display, form_data["bookmark_date_display"]
        )
        self.assertEqual(
            self.user.profile.bookmark_description_display,
            form_data["bookmark_description_display"],
        )
        self.assertEqual(
            self.user.profile.bookmark_description_max_lines,
            form_data["bookmark_description_max_lines"],
        )
        self.assertEqual(
            self.user.profile.bookmark_link_target, form_data["bookmark_link_target"]
        )
        self.assertEqual(
            self.user.profile.web_archive_integration,
            form_data["web_archive_integration"],
        )
        self.assertEqual(self.user.profile.enable_sharing, form_data["enable_sharing"])
        self.assertEqual(
            self.user.profile.enable_public_sharing, form_data["enable_public_sharing"]
        )
        self.assertEqual(
            self.user.profile.enable_favicons, form_data["enable_favicons"]
        )
        self.assertEqual(
            self.user.profile.enable_preview_images, form_data["enable_preview_images"]
        )
        self.assertEqual(
            self.user.profile.enable_automatic_html_snapshots,
            form_data["enable_automatic_html_snapshots"],
        )
        self.assertEqual(self.user.profile.tag_search, form_data["tag_search"])
        self.assertEqual(self.user.profile.tag_grouping, form_data["tag_grouping"])
        self.assertEqual(self.user.profile.display_url, form_data["display_url"])
        self.assertEqual(
            self.user.profile.display_view_bookmark_action,
            form_data["display_view_bookmark_action"],
        )
        self.assertEqual(
            self.user.profile.display_edit_bookmark_action,
            form_data["display_edit_bookmark_action"],
        )
        self.assertEqual(
            self.user.profile.display_archive_bookmark_action,
            form_data["display_archive_bookmark_action"],
        )
        self.assertEqual(
            self.user.profile.display_remove_bookmark_action,
            form_data["display_remove_bookmark_action"],
        )
        self.assertEqual(
            self.user.profile.permanent_notes, form_data["permanent_notes"]
        )
        self.assertEqual(
            self.user.profile.default_mark_unread, form_data["default_mark_unread"]
        )
        self.assertEqual(
            self.user.profile.default_mark_shared, form_data["default_mark_shared"]
        )
        self.assertEqual(self.user.profile.custom_css, form_data["custom_css"])
        self.assertEqual(
            self.user.profile.auto_tagging_rules, form_data["auto_tagging_rules"]
        )
        self.assertEqual(
            self.user.profile.items_per_page, int(form_data["items_per_page"])
        )
        self.assertEqual(
            self.user.profile.sticky_pagination, form_data["sticky_pagination"]
        )
        self.assertEqual(
            self.user.profile.collapse_side_panel, form_data["collapse_side_panel"]
        )
        self.assertEqual(self.user.profile.hide_bundles, form_data["hide_bundles"])
        self.assertEqual(self.user.profile.legacy_search, form_data["legacy_search"])

        self.assertSuccessMessage(html, "Profile updated")

    def test_update_profile_with_invalid_form_returns_422(self):
        form_data = self.create_profile_form_data({"items_per_page": "-1"})
        response = self.client.post(reverse("linkding:settings.update"), form_data)

        self.assertEqual(response.status_code, 422)

    def test_update_profile_should_not_be_called_without_respective_form_action(self):
        form_data = {
            "theme": UserProfile.THEME_DARK,
        }
        response = self.client.post(
            reverse("linkding:settings.update"), form_data, follow=True
        )
        html = response.content.decode()

        self.user.profile.refresh_from_db()

        self.assertEqual(response.status_code, 200)
        self.assertEqual(self.user.profile.theme, UserProfile.THEME_AUTO)
        self.assertSuccessMessage(html, "Profile updated", count=0)

    def test_update_profile_updates_custom_css_hash(self):
        form_data = self.create_profile_form_data(
            {
                "custom_css": "body { background-color: #000; }",
            }
        )
        self.client.post(reverse("linkding:settings.update"), form_data, follow=True)
        self.user.profile.refresh_from_db()

        expected_hash = hashlib.md5(form_data["custom_css"].encode("utf-8")).hexdigest()
        self.assertEqual(expected_hash, self.user.profile.custom_css_hash)

        form_data["custom_css"] = "body { background-color: #fff; }"
        self.client.post(reverse("linkding:settings.update"), form_data, follow=True)
        self.user.profile.refresh_from_db()

        expected_hash = hashlib.md5(form_data["custom_css"].encode("utf-8")).hexdigest()
        self.assertEqual(expected_hash, self.user.profile.custom_css_hash)

        form_data["custom_css"] = ""
        self.client.post(reverse("linkding:settings.update"), form_data, follow=True)
        self.user.profile.refresh_from_db()

        self.assertEqual("", self.user.profile.custom_css_hash)

    def test_enable_favicons_should_schedule_icon_update(self):
        with patch.object(
            tasks, "schedule_bookmarks_without_favicons"
        ) as mock_schedule_bookmarks_without_favicons:
            # Enabling favicons schedules update
            form_data = self.create_profile_form_data(
                {
                    "enable_favicons": True,
                }
            )
            self.client.post(reverse("linkding:settings.update"), form_data)

            mock_schedule_bookmarks_without_favicons.assert_called_once_with(self.user)

            # No update scheduled if favicons are already enabled
            mock_schedule_bookmarks_without_favicons.reset_mock()

            self.client.post(reverse("linkding:settings.update"), form_data)

            mock_schedule_bookmarks_without_favicons.assert_not_called()

            # No update scheduled when disabling favicons
            form_data = self.create_profile_form_data(
                {
                    "enable_favicons": False,
                }
            )

            self.client.post(reverse("linkding:settings.update"), form_data)

            mock_schedule_bookmarks_without_favicons.assert_not_called()

    def test_refresh_favicons(self):
        with patch.object(
            tasks, "schedule_refresh_favicons"
        ) as mock_schedule_refresh_favicons:
            form_data = {
                "refresh_favicons": "",
            }
            response = self.client.post(
                reverse("linkding:settings.update"), form_data, follow=True
            )
            html = response.content.decode()

            mock_schedule_refresh_favicons.assert_called_once()
            self.assertSuccessMessage(
                html, "Scheduled favicon update. This may take a while..."
            )

    def test_refresh_favicons_should_not_be_called_without_respective_form_action(self):
        with patch.object(
            tasks, "schedule_refresh_favicons"
        ) as mock_schedule_refresh_favicons:
            form_data = {}
            response = self.client.post(reverse("linkding:settings.update"), form_data)
            html = response.content.decode()

            mock_schedule_refresh_favicons.assert_not_called()
            self.assertSuccessMessage(
                html, "Scheduled favicon update. This may take a while...", count=0
            )

    def test_refresh_favicons_should_be_visible_when_favicons_enabled_in_profile(self):
        profile = self.get_or_create_test_user().profile
        profile.enable_favicons = True
        profile.save()

        response = self.client.get(reverse("linkding:settings.general"))
        html = response.content.decode()

        self.assertInHTML(
            """
            <button class="btn mt-2" name="refresh_favicons">Refresh Favicons</button>
        """,
            html,
            count=1,
        )

    def test_refresh_favicons_should_not_be_visible_when_favicons_disabled_in_profile(
        self,
    ):
        profile = self.get_or_create_test_user().profile
        profile.enable_favicons = False
        profile.save()

        response = self.client.get(reverse("linkding:settings.general"))
        html = response.content.decode()

        self.assertInHTML(
            """
            <button class="btn mt-2" name="refresh_favicons">Refresh Favicons</button>
        """,
            html,
            count=0,
        )

    @override_settings(LD_ENABLE_REFRESH_FAVICONS=False)
    def test_refresh_favicons_should_not_be_visible_when_disabled(self):
        profile = self.get_or_create_test_user().profile
        profile.enable_favicons = True
        profile.save()

        response = self.client.get(reverse("linkding:settings.general"))
        html = response.content.decode()

        self.assertInHTML(
            """
            <button class="btn mt-2" name="refresh_favicons">Refresh Favicons</button>
        """,
            html,
            count=0,
        )

    def test_enable_preview_image_should_schedule_preview_update(self):
        with patch.object(
            tasks, "schedule_bookmarks_without_previews"
        ) as mock_schedule_bookmarks_without_previews:
            # Enabling favicons schedules update
            form_data = self.create_profile_form_data(
                {
                    "enable_preview_images": True,
                }
            )
            self.client.post(reverse("linkding:settings.update"), form_data)

            mock_schedule_bookmarks_without_previews.assert_called_once_with(self.user)

            # No update scheduled if favicons are already enabled
            mock_schedule_bookmarks_without_previews.reset_mock()

            self.client.post(reverse("linkding:settings.update"), form_data)

            mock_schedule_bookmarks_without_previews.assert_not_called()

            # No update scheduled when disabling favicons
            form_data = self.create_profile_form_data(
                {
                    "enable_preview_images": False,
                }
            )

            self.client.post(reverse("linkding:settings.update"), form_data)

            mock_schedule_bookmarks_without_previews.assert_not_called()

    def test_automatic_html_snapshots_should_be_hidden_when_snapshots_not_supported(
        self,
    ):
        response = self.client.get(reverse("linkding:settings.general"))
        html = response.content.decode()

        self.assertInHTML(
            """
            <input type="checkbox" name="enable_automatic_html_snapshots"
            aria-describedby="id_enable_automatic_html_snapshots_help"
            id="id_enable_automatic_html_snapshots" checked="">
            """,
            html,
            count=0,
        )

    @override_settings(LD_ENABLE_SNAPSHOTS=True)
    def test_automatic_html_snapshots_should_be_visible_when_snapshots_supported(
        self,
    ):
        response = self.client.get(reverse("linkding:settings.general"))
        html = response.content.decode()

        self.assertInHTML(
            """
            <input type="checkbox" name="enable_automatic_html_snapshots"
            aria-describedby="id_enable_automatic_html_snapshots_help"
            id="id_enable_automatic_html_snapshots" checked="">
            """,
            html,
            count=1,
        )

    def test_about_shows_version_info(self):
        response = self.client.get(reverse("linkding:settings.general"))
        html = response.content.decode()

        self.assertInHTML(
            f"""
            <tr>
                <td>Version</td>
                <td>{get_version_info(random.random())}</td>
            </tr>
        """,
            html,
        )

    def test_get_version_info_just_displays_latest_when_versions_are_equal(self):
        latest_version_response_mock = Mock(
            status_code=200, json=lambda: {"name": f"v{app_version}"}
        )
        with patch.object(requests, "get", return_value=latest_version_response_mock):
            version_info = get_version_info(random.random())
            self.assertEqual(version_info, f"{app_version} (latest)")

    def test_get_version_info_shows_latest_version_when_versions_are_not_equal(self):
        latest_version_response_mock = Mock(
            status_code=200, json=lambda: {"name": "v123.0.1"}
        )
        with patch.object(requests, "get", return_value=latest_version_response_mock):
            version_info = get_version_info(random.random())
            self.assertEqual(version_info, f"{app_version} (latest: 123.0.1)")

    def test_get_version_info_silently_ignores_request_errors(self):
        with patch.object(requests, "get", side_effect=RequestException()):
            version_info = get_version_info(random.random())
            self.assertEqual(version_info, f"{app_version}")

    def test_get_version_info_handles_invalid_response(self):
        latest_version_response_mock = Mock(status_code=403, json=lambda: {})
        with patch.object(requests, "get", return_value=latest_version_response_mock):
            version_info = get_version_info(random.random())
            self.assertEqual(version_info, app_version)

        latest_version_response_mock = Mock(status_code=200, json=lambda: {})
        with patch.object(requests, "get", return_value=latest_version_response_mock):
            version_info = get_version_info(random.random())
            self.assertEqual(version_info, app_version)

    @override_settings(LD_ENABLE_SNAPSHOTS=True)
    def test_create_missing_html_snapshots(self):
        with patch.object(
            tasks, "create_missing_html_snapshots"
        ) as mock_create_missing_html_snapshots:
            mock_create_missing_html_snapshots.return_value = 5
            form_data = {
                "create_missing_html_snapshots": "",
            }
            response = self.client.post(
                reverse("linkding:settings.update"), form_data, follow=True
            )
            html = response.content.decode()

            self.assertEqual(response.status_code, 200)
            mock_create_missing_html_snapshots.assert_called_once()
            self.assertSuccessMessage(
                html, "Queued 5 missing snapshots. This may take a while..."
            )

    @override_settings(LD_ENABLE_SNAPSHOTS=True)
    def test_create_missing_html_snapshots_no_missing_snapshots(self):
        with patch.object(
            tasks, "create_missing_html_snapshots"
        ) as mock_create_missing_html_snapshots:
            mock_create_missing_html_snapshots.return_value = 0
            form_data = {
                "create_missing_html_snapshots": "",
            }
            response = self.client.post(
                reverse("linkding:settings.update"), form_data, follow=True
            )
            html = response.content.decode()

            self.assertEqual(response.status_code, 200)
            mock_create_missing_html_snapshots.assert_called_once()
            self.assertSuccessMessage(html, "No missing snapshots found.")

    def test_create_missing_html_snapshots_should_not_be_called_without_respective_form_action(
        self,
    ):
        with patch.object(
            tasks, "create_missing_html_snapshots"
        ) as mock_create_missing_html_snapshots:
            mock_create_missing_html_snapshots.return_value = 5
            form_data = {}
            response = self.client.post(
                reverse("linkding:settings.update"), form_data, follow=True
            )
            html = response.content.decode()

            self.assertEqual(response.status_code, 200)
            mock_create_missing_html_snapshots.assert_not_called()
            self.assertSuccessMessage(
                html, "Queued 5 missing snapshots. This may take a while...", count=0
            )

    def test_update_global_settings(self):
        superuser = self.setup_superuser()
        self.client.force_login(superuser)
        selectable_user = self.setup_user()

        # Update global settings
        form_data = {
            "update_global_settings": "",
            "landing_page": GlobalSettings.LANDING_PAGE_SHARED_BOOKMARKS,
            "guest_profile_user": selectable_user.id,
        }
        response = self.client.post(
            reverse("linkding:settings.update"), form_data, follow=True
        )
        self.assertEqual(response.status_code, 200)
        self.assertSuccessMessage(response.content.decode(), "Global settings updated")

        global_settings = GlobalSettings.get()
        self.assertEqual(global_settings.landing_page, form_data["landing_page"])
        self.assertEqual(global_settings.guest_profile_user, selectable_user)

        # Revert settings
        form_data = {
            "update_global_settings": "",
            "landing_page": GlobalSettings.LANDING_PAGE_LOGIN,
            "guest_profile_user": "",
        }
        response = self.client.post(
            reverse("linkding:settings.update"), form_data, follow=True
        )
        self.assertEqual(response.status_code, 200)
        self.assertSuccessMessage(response.content.decode(), "Global settings updated")

        global_settings = GlobalSettings.get()
        global_settings.refresh_from_db()
        self.assertEqual(global_settings.landing_page, form_data["landing_page"])
        self.assertIsNone(global_settings.guest_profile_user)

    def test_update_global_settings_should_not_be_called_without_respective_form_action(
        self,
    ):
        superuser = self.setup_superuser()
        self.client.force_login(superuser)

        form_data = {
            "landing_page": GlobalSettings.LANDING_PAGE_SHARED_BOOKMARKS,
        }
        response = self.client.post(
            reverse("linkding:settings.update"), form_data, follow=True
        )
        self.assertEqual(response.status_code, 200)
        self.assertSuccessMessage(
            response.content.decode(), "Global settings updated", count=0
        )

    def test_update_global_settings_checks_for_superuser(self):
        form_data = {
            "update_global_settings": "",
            "landing_page": GlobalSettings.LANDING_PAGE_SHARED_BOOKMARKS,
        }
        response = self.client.post(reverse("linkding:settings.update"), form_data)
        self.assertEqual(response.status_code, 403)

    def test_global_settings_only_visible_for_superuser(self):
        response = self.client.get(reverse("linkding:settings.general"))
        html = response.content.decode()

        self.assertInHTML(
            '<h2 id="global-settings-heading">Global settings</h2>',
            html,
            count=0,
        )

        superuser = self.setup_superuser()
        self.client.force_login(superuser)

        response = self.client.get(reverse("linkding:settings.general"))
        html = response.content.decode()

        self.assertInHTML(
            '<h2 id="global-settings-heading">Global settings</h2>',
            html,
            count=1,
        )


================================================
FILE: bookmarks/tests/test_settings_import_view.py
================================================
from django.test import TestCase
from django.urls import reverse

from bookmarks.models import Bookmark
from bookmarks.tests.helpers import BookmarkFactoryMixin, disable_logging


class SettingsImportViewTestCase(TestCase, BookmarkFactoryMixin):
    def setUp(self) -> None:
        user = self.get_or_create_test_user()
        self.client.force_login(user)

    def assertSuccessMessage(self, response, message: str):
        self.assertInHTML(
            f"""
            <div class="toast toast-success mb-4">{message}</div>
        """,
            response.content.decode("utf-8"),
        )

    def assertNoSuccessMessage(self, response):
        self.assertNotContains(response, '<div class="toast toast-success mb-4">')

    def assertErrorMessage(self, response, message: str):
        self.assertInHTML(
            f"""
            <div class="toast toast-error mb-4">{message}</div>
        """,
            response.content.decode("utf-8"),
        )

    def assertNoErrorMessage(self, response):
        self.assertNotContains(response, '<div class="toast toast-error mb-4">')

    def test_should_import_successfully(self):
        with open(
            "bookmarks/tests/resources/simple_valid_import_file.html"
        ) as import_file:
            response = self.client.post(
                reverse("linkding:settings.import"),
                {"import_file": import_file},
                follow=True,
            )

            self.assertRedirects(response, reverse("linkding:settings.general"))
            self.assertSuccessMessage(
                response, "3 bookmarks were successfully imported."
            )
            self.assertNoErrorMessage(response)

    def test_should_check_authentication(self):
        self.client.logout()
        response = self.client.get(reverse("linkding:settings.import"), follow=True)

        self.assertRedirects(
            response, reverse("login") + "?next=" + reverse("linkding:settings.import")
        )

    def test_should_show_hint_if_there_is_no_file(self):
        response = self.client.post(reverse("linkding:settings.import"), follow=True)

        self.assertRedirects(response, reverse("linkding:settings.general"))
        self.assertNoSuccessMessage(response)
        self.assertErrorMessage(response, "Please select a file to import.")

    @disable_logging
    def test_should_show_hint_if_import_raises_exception(self):
        with open(
            "bookmarks/tests/resources/invalid_import_file.png", "rb"
        ) as import_file:
            response = self.client.post(
                reverse("linkding:settings.import"),
                {"import_file": import_file},
                follow=True,
            )

            self.assertRedirects(response, reverse("linkding:settings.general"))
            self.assertNoSuccessMessage(response)
            self.assertErrorMessage(
                response, "An error occurred during bookmark import."
            )

    @disable_logging
    def test_should_show_respective_hints_if_not_all_bookmarks_were_imported_successfully(
        self,
    ):
        with open(
            "bookmarks/tests/resources/simple_valid_import_file_with_one_invalid_bookmark.html"
        ) as import_file:
            response = self.client.post(
                reverse("linkding:settings.import"),
                {"import_file": import_file},
                follow=True,
            )

            self.assertRedirects(response, reverse("linkding:settings.general"))
            self.assertSuccessMessage(
                response, "2 bookmarks were successfully imported."
            )
            self.assertErrorMessage(
                response,
                "1 bookmarks could not be imported. Please check the logs for more details.",
            )

    def test_should_respect_map_private_flag_option(self):
        with open(
            "bookmarks/tests/resources/simple_valid_import_file.html"
        ) as import_file:
            self.client.post(
                reverse("linkding:settings.import"),
                {"import_file": import_file},
                follow=True,
            )

            self.assertEqual(Bookmark.objects.count(), 3)
            self.assertEqual(Bookmark.objects.all()[0].shared, False)
            self.assertEqual(Bookmark.objects.all()[1].shared, False)
            self.assertEqual(Bookmark.objects.all()[2].shared, False)

        Bookmark.objects.all().delete()

        with open(
            "bookmarks/tests/resources/simple_valid_import_file.html"
        ) as import_file:
            self.client.post(
                reverse("linkding:settings.import"),
                {"import_file": import_file, "map_private_flag": "on"},
                follow=True,
            )

            self.assertEqual(Bookmark.objects.count(), 3)
            self.assertEqual(Bookmark.objects.all()[0].shared, True)
            self.assertEqual(Bookmark.objects.all()[1].shared, True)
            self.assertEqual(Bookmark.objects.all()[2].shared, True)


================================================
FILE: bookmarks/tests/test_settings_integrations_view.py
================================================
from django.test import TestCase
from django.urls import reverse

from bookmarks.models import ApiToken, FeedToken
from bookmarks.tests.helpers import BookmarkFactoryMixin, HtmlTestMixin


class SettingsIntegrationsViewTestCase(TestCase, BookmarkFactoryMixin, HtmlTestMixin):
    def setUp(self) -> None:
        user = self.get_or_create_test_user()
        self.client.force_login(user)

    def test_should_render_successfully(self):
        response = self.client.get(reverse("linkding:settings.integrations"))

        self.assertEqual(response.status_code, 200)

    def test_should_check_authentication(self):
        self.client.logout()
        response = self.client.get(
            reverse("linkding:settings.integrations"), follow=True
        )

        self.assertRedirects(
            response,
            reverse("login") + "?next=" + reverse("linkding:settings.integrations"),
        )

    def test_create_api_token(self):
        response = self.client.post(
            reverse("linkding:settings.integrations.create_api_token"),
            {"name": "My Test Token"},
        )

        self.assertRedirects(response, reverse("linkding:settings.integrations"))
        self.assertEqual(ApiToken.objects.count(), 1)
        token = ApiToken.objects.first()
        self.assertEqual(token.user, self.user)
        self.assertEqual(token.name, "My Test Token")

    def test_create_api_token_with_empty_name(self):
        self.client.post(
            reverse("linkding:settings.integrations.create_api_token"),
            {"name": ""},
        )

        self.assertEqual(ApiToken.objects.count(), 1)
        token = ApiToken.objects.first()
        self.assertEqual(token.name, "API Token")

    def test_create_api_token_shows_key_once(self):
        self.client.post(
            reverse("linkding:settings.integrations.create_api_token"),
            {"name": "My Token"},
        )

        # First load should show the token
        response = self.client.get(reverse("linkding:settings.integrations"))
        token = ApiToken.objects.first()
        self.assertContains(response, token.key)

        # Second load should not show the token
        response = self.client.get(reverse("linkding:settings.integrations"))
        self.assertNotContains(response, token.key)

    def test_delete_api_token(self):
        token = self.setup_api_token(name="To Delete")

        response = self.client.post(
            reverse("linkding:settings.integrations.delete_api_token"),
            {"token_id": token.id},
        )

        self.assertRedirects(response, reverse("linkding:settings.integrations"))
        self.assertEqual(ApiToken.objects.count(), 0)

    def test_delete_api_token_wrong_user(self):
        other_user = self.setup_user(name="other")
        token = self.setup_api_token(user=other_user, name="Other's Token")

        response = self.client.post(
            reverse("linkding:settings.integrations.delete_api_token"),
            {"token_id": token.id},
        )

        self.assertEqual(response.status_code, 404)
        self.assertEqual(ApiToken.objects.count(), 1)

    def test_list_api_tokens(self):
        self.setup_api_token(name="Token 1")
        self.setup_api_token(name="Token 2")

        other_user = self.setup_user(name="other")
        self.setup_api_token(user=other_user, name="Other's Token")

        response = self.client.get(reverse("linkding:settings.integrations"))
        soup = self.make_soup(response.content.decode())

        section = soup.find("turbo-frame", id="api-section")
        table = section.find("table")
        rows = table.find_all("tr")

        self.assertEqual(len(rows), 3)

        first_row_cells = rows[1].find_all("td")
        self.assertEqual(first_row_cells[0].get_text(strip=True), "Token 2")
        self.assertIsNotNone(first_row_cells[1].get_text(strip=True))

        second_row_cells = rows[2].find_all("td")
        self.assertEqual(second_row_cells[0].get_text(strip=True), "Token 1")
        self.assertIsNotNone(second_row_cells[1].get_text(strip=True))

    def test_should_generate_feed_token_if_not_exists(self):
        self.assertEqual(FeedToken.objects.count(), 0)

        self.client.get(reverse("linkding:settings.integrations"))

        self.assertEqual(FeedToken.objects.count(), 1)
        token = FeedToken.objects.first()
        self.assertEqual(token.user, self.user)

    def test_should_not_generate_feed_token_if_exists(self):
        FeedToken.objects.get_or_create(user=self.user)
        self.assertEqual(FeedToken.objects.count(), 1)

        self.client.get(reverse("linkding:settings.integrations"))

        self.assertEqual(FeedToken.objects.count(), 1)

    def test_should_display_feed_urls(self):
        response = self.client.get(reverse("linkding:settings.integrations"))
        html = response.content.decode()

        token = FeedToken.objects.first()
        self.assertInHTML(
            f'<a target="_blank" href="/feeds/{token.key}/all">All bookmarks</a>',
            html,
        )
        self.assertInHTML(
            f'<a target="_blank" href="/feeds/{token.key}/unread">Unread bookmarks</a>',
            html,
        )
        self.assertInHTML(
            f'<a target="_blank" href="/feeds/{token.key}/shared">Shared bookmarks</a>',
            html,
        )
        self.assertInHTML(
            '<a target="_blank" href="/feeds/shared">Public shared bookmarks</a>',
            html,
        )


================================================
FILE: bookmarks/tests/test_singlefile_service.py
================================================
import os
import subprocess
import tempfile
from unittest import mock

from django.test import TestCase, override_settings

from bookmarks.services import singlefile


class SingleFileServiceTestCase(TestCase):
    def setUp(self):
        self.temp_html_filepath = None

    def tearDown(self):
        if self.temp_html_filepath and os.path.exists(self.temp_html_filepath):
            os.remove(self.temp_html_filepath)

    def create_test_file(self, *args, **kwargs):
        self.temp_html_filepath = tempfile.mkstemp(suffix=".tmp")[1]

    def test_create_snapshot_failure(self):
        # subprocess fails - which it probably doesn't as single-file doesn't return exit codes
        with mock.patch("subprocess.Popen") as mock_popen:
            mock_popen.side_effect = subprocess.CalledProcessError(1, "command")

            with self.assertRaises(singlefile.SingleFileError):
                singlefile.create_snapshot("http://example.com", "nonexistentfile.tmp")

        # so also check that it raises error if output file isn't created
        with (
            mock.patch("subprocess.Popen"),
            self.assertRaises(singlefile.SingleFileError),
        ):
            singlefile.create_snapshot("http://example.com", "nonexistentfile.tmp")

    def test_create_snapshot_empty_options(self):
        mock_process = mock.Mock()
        mock_process.wait.return_value = 0
        self.create_test_file()

        with mock.patch("subprocess.Popen") as mock_popen:
            singlefile.create_snapshot("http://example.com", self.temp_html_filepath)

            expected_args = [
                "single-file",
                '--browser-arg="--headless=new"',
                '--browser-arg="--user-data-dir=./chromium-profile"',
                '--browser-arg="--no-sandbox"',
                '--browser-arg="--load-extension=uBOLite.chromium.mv3"',
                "http://example.com",
                self.temp_html_filepath,
            ]
            mock_popen.assert_called_with(expected_args, start_new_session=True)

    @override_settings(
        LD_SINGLEFILE_OPTIONS='--some-option "some value" --another-option "another value" --third-option="third value"'
    )
    def test_create_snapshot_custom_options(self):
        mock_process = mock.Mock()
        mock_process.wait.return_value = 0
        self.create_test_file()

        with mock.patch("subprocess.Popen") as mock_popen:
            singlefile.create_snapshot("http://example.com", self.temp_html_filepath)

            expected_args = [
                "single-file",
                '--browser-arg="--headless=new"',
                '--browser-arg="--user-data-dir=./chromium-profile"',
                '--browser-arg="--no-sandbox"',
                '--browser-arg="--load-extension=uBOLite.chromium.mv3"',
                "--some-option",
                "some value",
                "--another-option",
                "another value",
                "--third-option=third value",
                "http://example.com",
                self.temp_html_filepath,
            ]
            mock_popen.assert_called_with(expected_args, start_new_session=True)

    def test_create_snapshot_default_timeout_setting(self):
        mock_process = mock.Mock()
        mock_process.wait.return_value = 0
        self.create_test_file()

        with mock.patch("subprocess.Popen", return_value=mock_process):
            singlefile.create_snapshot("http://example.com", self.temp_html_filepath)

            mock_process.wait.assert_called_with(timeout=120)

    @override_settings(LD_SINGLEFILE_TIMEOUT_SEC=180)
    def test_create_snapshot_custom_timeout_setting(self):
        mock_process = mock.Mock()
        mock_process.wait.return_value = 0
        self.create_test_file()

        with mock.patch("subprocess.Popen", return_value=mock_process):
            singlefile.create_snapshot("http://example.com", self.temp_html_filepath)

            mock_process.wait.assert_called_with(timeout=180)


================================================
FILE: bookmarks/tests/test_tag_cloud_template.py
================================================
from django.contrib.auth.models import AnonymousUser, User
from django.http import HttpResponse
from django.template import RequestContext, Template
from django.test import RequestFactory, TestCase

from bookmarks.middlewares import LinkdingMiddleware
from bookmarks.models import BookmarkSearch, UserProfile
from bookmarks.tests.helpers import BookmarkFactoryMixin, HtmlTestMixin
from bookmarks.views import contexts


class TagCloudTemplateTest(TestCase, BookmarkFactoryMixin, HtmlTestMixin):
    def render_template(
        self,
        context_type: type[contexts.TagCloudContext] = contexts.ActiveTagCloudContext,
        url: str = "/test",
        user: User | AnonymousUser = None,
    ):
        rf = RequestFactory()
        request = rf.get(url)
        request.user = user or self.get_or_create_test_user()
        middleware = LinkdingMiddleware(lambda r: HttpResponse())
        middleware(request)

        search = BookmarkSearch.from_request(
            request, request.GET, request.user_profile.search_preferences
        )
        tag_cloud_context = context_type(request, search)
        context = RequestContext(request, {"tag_cloud": tag_cloud_context})
        template_to_render = Template("{% include 'bookmarks/tag_cloud.html' %}")
        return template_to_render.render(context)

    def assertTagGroups(
        self,
        rendered_template: str,
        groups: list[list[str]],
        highlight_first_char: bool = True,
    ):
        soup = self.make_soup(rendered_template)
        group_elements = soup.select("p.group")

        self.assertEqual(len(group_elements), len(groups))

        for group_index, tags in enumerate(groups, start=0):
            group_element = group_elements[group_index]
            link_elements = group_element.select("a")

            self.assertEqual(len(link_elements), len(tags), tags)

            for tag_index, tag in enumerate(tags, start=0):
                link_element = link_elements[tag_index]
                self.assertEqual(link_element.text.strip(), tag)

                if tag_index == 0:
                    if highlight_first_char:
                        self.assertIn(
                            f'<span class="highlight-char">{tag[0]}</span>',
                            str(link_element),
                        )
                    else:
                        self.assertNotIn(
                            f'<span class="highlight-char">{tag[0]}</span>',
                            str(link_element),
                        )

    def assertNumSelectedTags(self, rendered_template: str, count: int):
        soup = self.make_soup(rendered_template)
        link_elements = soup.select("p.selected-tags a")
        self.assertEqual(len(link_elements), count)

    def test_cjk_using_single_group(self):
        """
        Ideographic characters will be using the same group
        While other japanese and korean characters will have separate groups.
        """
        tags = [
            self.setup_tag(name="Aardvark"),
            self.setup_tag(name="Armadillo"),
            self.setup_tag(name="あひる"),
            self.setup_tag(name="あきらか"),
            self.setup_tag(name="アヒル"),
            self.setup_tag(name="アキラカ"),
            self.setup_tag(name="ひる"),
            self.setup_tag(name="アヒル"),
            self.setup_tag(name="오리"),
            self.setup_tag(name="물"),
            self.setup_tag(name="家鴨"),
            self.setup_tag(name="感じ"),
        ]
        self.setup_bookmark(tags=tags)
        rendered_template = self.render_template()

        self.assertTagGroups(
            rendered_template,
            [
                [
                    "Aardvark",
                    "Armadillo",
                ],
                [
                    "あきらか",
                    "あひる",
                ],
                [
                    "ひる",
                ],
                [
                    "アキラカ",
                    "アヒル",
                ],
                [
                    "물",
                ],
                [
                    "오리",
                ],
                [
                    "家鴨",
                    "感じ",
                ],
            ],
        )

    def test_group_alphabetically(self):
        tags = [
            self.setup_tag(name="Cockatoo"),
            self.setup_tag(name="Badger"),
            self.setup_tag(name="Buffalo"),
            self.setup_tag(name="Chihuahua"),
            self.setup_tag(name="Alpaca"),
            self.setup_tag(name="Coyote"),
            self.setup_tag(name="Aardvark"),
            self.setup_tag(name="Bumblebee"),
            self.setup_tag(name="Armadillo"),
        ]
        self.setup_bookmark(tags=tags)

        rendered_template = self.render_template()

        self.assertTagGroups(
            rendered_template,
            [
                [
                    "Aardvark",
                    "Alpaca",
                    "Armadillo",
                ],
                [
                    "Badger",
                    "Buffalo",
                    "Bumblebee",
                ],
                [
                    "Chihuahua",
                    "Cockatoo",
                    "Coyote",
                ],
            ],
        )

    def test_group_when_grouping_disabled(self):
        profile = self.get_or_create_test_user().profile
        profile.tag_grouping = UserProfile.TAG_GROUPING_DISABLED
        profile.save()

        tags = [
            self.setup_tag(name="Cockatoo"),
            self.setup_tag(name="Badger"),
            self.setup_tag(name="Buffalo"),
            self.setup_tag(name="Chihuahua"),
            self.setup_tag(name="Alpaca"),
            self.setup_tag(name="Coyote"),
            self.setup_tag(name="Aardvark"),
            self.setup_tag(name="Bumblebee"),
            self.setup_tag(name="Armadillo"),
        ]
        self.setup_bookmark(tags=tags)

        rendered_template = self.render_template()

        self.assertTagGroups(
            rendered_template,
            [
                [
                    "Aardvark",
                    "Alpaca",
                    "Armadillo",
                    "Badger",
                    "Buffalo",
                    "Bumblebee",
                    "Chihuahua",
                    "Cockatoo",
                    "Coyote",
                ],
            ],
            False,
        )

    def test_no_duplicate_tag_names(self):
        tags = [
            self.setup_tag(name="shared", user=self.setup_user(enable_sharing=True)),
            self.setup_tag(name="shared", user=self.setup_user(enable_sharing=True)),
            self.setup_tag(name="shared", user=self.setup_user(enable_sharing=True)),
        ]
        for tag in tags:
            self.setup_bookmark(tags=[tag], user=tag.owner, shared=True)

        rendered_template = self.render_template(
            context_type=contexts.SharedTagCloudContext
        )

        self.assertTagGroups(
            rendered_template,
            [
                [
                    "shared",
                ],
            ],
        )

    def test_tag_url_respects_search_options(self):
        tag = self.setup_tag(name="tag1")
        self.setup_bookmark(tags=[tag], title="term1")

        rendered_template = self.render_template(url="/test?q=term1&sort=title_asc")

        self.assertInHTML(
            """
            <a href="?q=term1+%23tag1&sort=title_asc" class="mr-2" data-is-tag-item>
              <span class="highlight-char">t</span><span>ag1</span>
            </a>
        """,
            rendered_template,
        )

    def test_tag_url_removes_page_number_and_details_id(self):
        tag = self.setup_tag(name="tag1")
        self.setup_bookmark(tags=[tag], title="term1")

        rendered_template = self.render_template(
            url="/test?q=term1&sort=title_asc&page=2&details=5"
        )

        self.assertInHTML(
            """
            <a href="?q=term1+%23tag1&sort=title_asc" class="mr-2" data-is-tag-item>
              <span class="highlight-char">t</span><span>ag1</span>
            </a>
        """,
            rendered_template,
        )

    def test_tag_url_wraps_or_expression_in_parenthesis(self):
        tag = self.setup_tag(name="tag1")
        self.setup_bookmark(tags=[tag], title="term1")

        rendered_template = self.render_template(url="/test?q=term1 or term2")

        self.assertInHTML(
            """
            <a href="?q=%28term1+or+term2%29+%23tag1" class="mr-2" data-is-tag-item>
              <span class="highlight-char">t</span><span>ag1</span>
            </a>
        """,
            rendered_template,
        )

    def test_selected_tags(self):
        tags = [
            self.setup_tag(name="tag1"),
            self.setup_tag(name="tag2"),
        ]
        self.setup_bookmark(tags=tags)

        rendered_template = self.render_template(url="/test?q=%23tag1 %23tag2")

        self.assertNumSelectedTags(rendered_template, 2)

        self.assertInHTML(
            """
            <a href="?q=%23tag2"
               class="text-bold mr-2">
                <span>-tag1</span>
            </a>
        """,
            rendered_template,
        )

        self.assertInHTML(
            """
            <a href="?q=%23tag1"
               class="text-bold mr-2">
                <span>-tag2</span>
            </a>
        """,
            rendered_template,
        )

    def test_selected_tags_complex_queries(self):
        tags = [
            self.setup_tag(name="tag1"),
            self.setup_tag(name="tag2"),
        ]
        self.setup_bookmark(tags=tags)

        rendered_template = self.render_template(url="/test?q=%23tag1 or not %23tag2")

        self.assertNumSelectedTags(rendered_template, 2)

        self.assertInHTML(
            """
            <a href="?q=not+%23tag2"
               class="text-bold mr-2">
                <span>-tag1</span>
            </a>
        """,
            rendered_template,
        )

        self.assertInHTML(
            """
            <a href="?q=%23tag1"
               class="text-bold mr-2">
                <span>-tag2</span>
            </a>
        """,
            rendered_template,
        )

        rendered_template = self.render_template(
            url="/test?q=%23tag1 and not (%23tag2 or term)"
        )

        self.assertNumSelectedTags(rendered_template, 2)

        self.assertInHTML(
            """
            <a href="?q=not+%28%23tag2+or+term%29"
               class="text-bold mr-2">
                <span>-tag1</span>
            </a>
        """,
            rendered_template,
        )

        self.assertInHTML(
            """
            <a href="?q=%23tag1+not+term"
               class="text-bold mr-2">
                <span>-tag2</span>
            </a>
        """,
            rendered_template,
        )

    def test_selected_tags_with_lax_tag_search(self):
        profile = self.get_or_create_test_user().profile
        profile.tag_search = UserProfile.TAG_SEARCH_LAX
        profile.save()

        tags = [
            self.setup_tag(name="tag1"),
            self.setup_tag(name="tag2"),
        ]
        self.setup_bookmark(tags=tags)

        # Filter by tag name without hash
        rendered_template = self.render_template(url="/test?q=tag1 %23tag2")

        self.assertNumSelectedTags(rendered_template, 2)

        # Tag name should still be removed from query string
        self.assertInHTML(
            """
            <a href="?q=%23tag2"
               class="text-bold mr-2">
                <span>-tag1</span>
            </a>
        """,
            rendered_template,
        )

        self.assertInHTML(
            """
            <a href="?q=tag1"
               class="text-bold mr-2">
                <span>-tag2</span>
            </a>
        """,
            rendered_template,
        )

    def test_selected_tags_ignore_casing_when_removing_query_part(self):
        tags = [
            self.setup_tag(name="TEST"),
        ]
        self.setup_bookmark(tags=tags)

        rendered_template = self.render_template(url="/test?q=%23test")

        self.assertInHTML(
            """
            <a href="?q="
               class="text-bold mr-2">
                <span>-TEST</span>
            </a>
        """,
            rendered_template,
        )

    def test_no_duplicate_selected_tags(self):
        tags = [
            self.setup_tag(name="shared", user=self.setup_user(enable_sharing=True)),
            self.setup_tag(name="shared", user=self.setup_user(enable_sharing=True)),
            self.setup_tag(name="shared", user=self.setup_user(enable_sharing=True)),
        ]
        for tag in tags:
            self.setup_bookmark(tags=[tag], shared=True, user=tag.owner)

        rendered_template = self.render_template(
            context_type=contexts.SharedTagCloudContext, url="/test?q=%23shared"
        )

        self.assertInHTML(
            """
            <a href="?q="
               class="text-bold mr-2">
                <span>-shared</span>
            </a>
        """,
            rendered_template,
            count=1,
        )

    def test_selected_tag_url_keeps_other_query_terms(self):
        tag = self.setup_tag(name="tag1")
        self.setup_bookmark(tags=[tag], title="term1", description="term2")

        rendered_template = self.render_template(url="/test?q=term1 %23tag1 term2")

        self.assertInHTML(
            """
            <a href="?q=term1+term2"
               class="text-bold mr-2">
                <span>-tag1</span>
            </a>
        """,
            rendered_template,
        )

    def test_selected_tag_url_respects_search_options(self):
        tag = self.setup_tag(name="tag1")
        self.setup_bookmark(tags=[tag], title="term1", description="term2")

        rendered_template = self.render_template(
            url="/test?q=term1 %23tag1 term2&sort=title_asc"
        )

        self.assertInHTML(
            """
            <a href="?q=term1+term2&sort=title_asc"
               class="text-bold mr-2">
                <span>-tag1</span>
            </a>
        """,
            rendered_template,
        )

    def test_selected_tag_url_removes_page_number_and_details_id(self):
        tag = self.setup_tag(name="tag1")
        self.setup_bookmark(tags=[tag], title="term1", description="term2")

        rendered_template = self.render_template(
            url="/test?q=term1 %23tag1 term2&sort=title_asc&page=2&details=5"
        )

        self.assertInHTML(
            """
            <a href="?q=term1+term2&sort=title_asc"
               class="text-bold mr-2">
                <span>-tag1</span>
            </a>
        """,
            rendered_template,
        )

    def test_selected_tags_are_excluded_from_groups(self):
        tags = [
            self.setup_tag(name="tag1"),
            self.setup_tag(name="tag2"),
            self.setup_tag(name="tag3"),
            self.setup_tag(name="tag4"),
            self.setup_tag(name="tag5"),
        ]
        self.setup_bookmark(tags=tags)

        rendered_template = self.render_template(url="/test?q=%23tag1 %23tag2")

        self.assertTagGroups(rendered_template, [["tag3", "tag4", "tag5"]])

        rendered_template = self.render_template(
            url="/test?q=%23tag1 or (%23tag2 or not term)"
        )

        self.assertTagGroups(rendered_template, [["tag3", "tag4", "tag5"]])

    def test_with_anonymous_user(self):
        profile = self.get_or_create_test_user().profile
        profile.enable_sharing = True
        profile.enable_public_sharing = True
        profile.save()

        tags = [
            self.setup_tag(name="tag1"),
            self.setup_tag(name="tag2"),
            self.setup_tag(name="tag3"),
            self.setup_tag(name="tag4"),
            self.setup_tag(name="tag5"),
        ]
        self.setup_bookmark(tags=tags, shared=True)

        rendered_template = self.render_template(
            context_type=contexts.SharedTagCloudContext,
            url="/test?q=%23tag1 %23tag2",
            user=AnonymousUser(),
        )

        self.assertTagGroups(rendered_template, [["tag3", "tag4", "tag5"]])
        self.assertNumSelectedTags(rendered_template, 2)
        self.assertInHTML(
            """
            <a href="?q=%23tag2"
               class="text-bold mr-2">
                <span>-tag1</span>
            </a>
        """,
            rendered_template,
        )

        self.assertInHTML(
            """
            <a href="?q=%23tag1"
               class="text-bold mr-2">
                <span>-tag2</span>
            </a>
        """,
            rendered_template,
        )


================================================
FILE: bookmarks/tests/test_tags_edit_view.py
================================================
from django.test import TestCase
from django.urls import reverse

from bookmarks.tests.helpers import BookmarkFactoryMixin


class TagsEditViewTestCase(TestCase, BookmarkFactoryMixin):
    def setUp(self) -> None:
        self.user = self.get_or_create_test_user()
        self.client.force_login(self.user)

    def test_update_tag(self):
        tag = self.setup_tag(name="old_name")

        response = self.client.post(
            reverse("linkding:tags.edit", args=[tag.id]), {"name": "new_name"}
        )

        self.assertRedirects(response, reverse("linkding:tags.index"))

        tag.refresh_from_db()
        self.assertEqual(tag.name, "new_name")

    def test_allow_case_changes(self):
        tag = self.setup_tag(name="tag")

        self.client.post(reverse("linkding:tags.edit", args=[tag.id]), {"name": "TAG"})

        tag.refresh_from_db()
        self.assertEqual(tag.name, "TAG")

    def test_can_only_edit_own_tags(self):
        other_user = self.setup_user()
        tag = self.setup_tag(user=other_user)

        response = self.client.post(
            reverse("linkding:tags.edit", args=[tag.id]), {"name": "new_name"}
        )

        self.assertEqual(response.status_code, 404)
        tag.refresh_from_db()
        self.assertNotEqual(tag.name, "new_name")

    def test_show_error_for_empty_name(self):
        tag = self.setup_tag(name="tag1")

        response = self.client.post(
            reverse("linkding:tags.edit", args=[tag.id]), {"name": ""}
        )

        self.assertContains(response, "This field is required")
        tag.refresh_from_db()
        self.assertEqual(tag.name, "tag1")

    def test_show_error_for_duplicate_name(self):
        tag1 = self.setup_tag(name="tag1")
        self.setup_tag(name="tag2")

        response = self.client.post(
            reverse("linkding:tags.edit", args=[tag1.id]), {"name": "tag2"}
        )

        self.assertContains(response, "Tag &quot;tag2&quot; already exists")
        tag1.refresh_from_db()
        self.assertEqual(tag1.name, "tag1")

    def test_show_error_for_duplicate_name_different_casing(self):
        tag1 = self.setup_tag(name="tag1")
        self.setup_tag(name="tag2")

        response = self.client.post(
            reverse("linkding:tags.edit", args=[tag1.id]), {"name": "TAG2"}
        )

        self.assertContains(response, "Tag &quot;TAG2&quot; already exists")
        tag1.refresh_from_db()
        self.assertEqual(tag1.name, "tag1")

    def test_no_error_for_duplicate_name_different_user(self):
        other_user = self.setup_user()
        self.setup_tag(name="tag1", user=other_user)

        tag2 = self.setup_tag(name="tag2")

        response = self.client.post(
            reverse("linkding:tags.edit", args=[tag2.id]), {"name": "tag1"}
        )

        self.assertRedirects(response, reverse("linkding:tags.index"))
        tag2.refresh_from_db()
        self.assertEqual(tag2.name, "tag1")

    def test_update_tag_preserves_query_parameters(self):
        tag = self.setup_tag(name="old_name")

        url = (
            reverse("linkding:tags.edit", args=[tag.id])
            + "?search=search&unused=true&page=2&sort=name-desc"
        )
        response = self.client.post(url, {"name": "new_name"})

        expected_redirect = (
            reverse("linkding:tags.index")
            + "?search=search&unused=true&page=2&sort=name-desc"
        )
        self.assertRedirects(response, expected_redirect)


================================================
FILE: bookmarks/tests/test_tags_index_view.py
================================================
from django.test import TestCase
from django.urls import reverse

from bookmarks.models import Tag
from bookmarks.tests.helpers import BookmarkFactoryMixin, HtmlTestMixin


class TagsIndexViewTestCase(TestCase, BookmarkFactoryMixin, HtmlTestMixin):
    def setUp(self) -> None:
        self.user = self.get_or_create_test_user()
        self.client.force_login(self.user)

    def get_rows(self, response):
        html = response.content.decode()
        soup = self.make_soup(html)
        return soup.select(".crud-table tbody tr")

    def find_row(self, rows, tag):
        for row in rows:
            if tag.name in row.get_text():
                return row
        return None

    def assertRows(self, response, tags):
        rows = self.get_rows(response)
        self.assertEqual(len(rows), len(tags))
        for tag in tags:
            row = self.find_row(rows, tag)
            self.assertIsNotNone(row, f"Tag '{tag.name}' not found in table")

    def assertOrderedRows(self, response, tags):
        rows = self.get_rows(response)
        self.assertEqual(len(rows), len(tags))
        for index, tag in enumerate(tags):
            row = rows[index]
            self.assertIn(
                tag.name,
                row.get_text(),
                f"Tag '{tag.name}' not found at index {index}",
            )

    def test_list_tags(self):
        tag1 = self.setup_tag()
        tag2 = self.setup_tag()
        tag3 = self.setup_tag()

        response = self.client.get(reverse("linkding:tags.index"))

        self.assertEqual(response.status_code, 200)
        self.assertRows(response, [tag1, tag2, tag3])

    def test_show_user_owned_tags(self):
        tag1 = self.setup_tag()
        tag2 = self.setup_tag()
        tag3 = self.setup_tag()

        other_user = self.setup_user()
        self.setup_tag(user=other_user)
        self.setup_tag(user=other_user)
        self.setup_tag(user=other_user)

        response = self.client.get(reverse("linkding:tags.index"))

        self.assertRows(response, [tag1, tag2, tag3])

    def test_search_tags(self):
        tag1 = self.setup_tag(name="programming")
        self.setup_tag(name="python")
        self.setup_tag(name="django")
        self.setup_tag(name="design")

        response = self.client.get(reverse("linkding:tags.index") + "?search=prog")

        self.assertRows(response, [tag1])

    def test_filter_unused_tags(self):
        tag1 = self.setup_tag()
        tag2 = self.setup_tag()
        tag3 = self.setup_tag()

        self.setup_bookmark(tags=[tag1])
        self.setup_bookmark(tags=[tag3])

        response = self.client.get(reverse("linkding:tags.index") + "?unused=true")

        self.assertRows(response, [tag2])

    def test_rows_have_links_to_filtered_bookmarks(self):
        tag1 = self.setup_tag(name="python")
        tag2 = self.setup_tag(name="django-framework")

        self.setup_bookmark(tags=[tag1])
        self.setup_bookmark(tags=[tag1, tag2])

        response = self.client.get(reverse("linkding:tags.index"))

        rows = self.get_rows(response)

        tag1_row = self.find_row(rows, tag1)
        view_link = tag1_row.find("a", string=lambda s: s and s.strip() == "2")
        expected_url = reverse("linkding:bookmarks.index") + "?q=%23python"
        self.assertEqual(view_link["href"], expected_url)

        tag2_row = self.find_row(rows, tag2)
        view_link = tag2_row.find("a", string=lambda s: s and s.strip() == "1")
        expected_url = reverse("linkding:bookmarks.index") + "?q=%23django-framework"
        self.assertEqual(view_link["href"], expected_url)

    def test_shows_tag_total(self):
        tag1 = self.setup_tag(name="python")
        tag2 = self.setup_tag(name="javascript")
        tag3 = self.setup_tag(name="design")
        self.setup_tag(name="unused-tag")

        self.setup_bookmark(tags=[tag1])
        self.setup_bookmark(tags=[tag2])
        self.setup_bookmark(tags=[tag3])

        response = self.client.get(reverse("linkding:tags.index"))
        self.assertContains(response, "4 tags total")

        response = self.client.get(reverse("linkding:tags.index") + "?search=python")
        self.assertContains(response, "Showing 1 of 4 tags")

        response = self.client.get(reverse("linkding:tags.index") + "?unused=true")
        self.assertContains(response, "Showing 1 of 4 tags")

        response = self.client.get(
            reverse("linkding:tags.index") + "?search=nonexistent"
        )
        self.assertContains(response, "Showing 0 of 4 tags")

    def test_pagination(self):
        tags = []
        for _i in range(75):
            tags.append(self.setup_tag())

        response = self.client.get(reverse("linkding:tags.index"))
        rows = self.get_rows(response)
        self.assertEqual(len(rows), 50)

        response = self.client.get(reverse("linkding:tags.index") + "?page=2")
        rows = self.get_rows(response)
        self.assertEqual(len(rows), 25)

    def test_delete_action(self):
        tag = self.setup_tag(name="tag_to_delete")

        response = self.client.post(
            reverse("linkding:tags.index"), {"delete_tag": tag.id}
        )

        self.assertRedirects(response, reverse("linkding:tags.index"))
        self.assertFalse(Tag.objects.filter(id=tag.id).exists())

    def test_tag_delete_action_preserves_query_parameters(self):
        tag = self.setup_tag(name="search_tag")

        url = (
            reverse("linkding:tags.index")
            + "?search=search&unused=true&page=2&sort=name-desc"
        )
        response = self.client.post(url, {"delete_tag": tag.id})

        self.assertRedirects(response, url)

    def test_tag_delete_action_only_deletes_own_tags(self):
        other_user = self.setup_user()
        other_tag = self.setup_tag(user=other_user, name="other_user_tag")

        response = self.client.post(
            reverse("linkding:tags.index"), {"delete_tag": other_tag.id}, follow=True
        )

        self.assertEqual(response.status_code, 404)

    def test_sort_by_name_ascending(self):
        tag_c = self.setup_tag(name="c_tag")
        tag_a = self.setup_tag(name="a_tag")
        tag_b = self.setup_tag(name="b_tag")

        response = self.client.get(reverse("linkding:tags.index") + "?sort=name-asc")

        self.assertOrderedRows(response, [tag_a, tag_b, tag_c])

    def test_sort_by_name_descending(self):
        tag_c = self.setup_tag(name="c_tag")
        tag_a = self.setup_tag(name="a_tag")
        tag_b = self.setup_tag(name="b_tag")

        response = self.client.get(reverse("linkding:tags.index") + "?sort=name-desc")

        self.assertOrderedRows(response, [tag_c, tag_b, tag_a])

    def test_sort_by_bookmark_count_ascending(self):
        tag_few = self.setup_tag(name="few_bookmarks")
        tag_many = self.setup_tag(name="many_bookmarks")
        tag_none = self.setup_tag(name="no_bookmarks")

        self.setup_bookmark(tags=[tag_few])
        self.setup_bookmark(tags=[tag_many])
        self.setup_bookmark(tags=[tag_many])
        self.setup_bookmark(tags=[tag_many])

        response = self.client.get(reverse("linkding:tags.index") + "?sort=count-asc")

        self.assertOrderedRows(response, [tag_none, tag_few, tag_many])

    def test_sort_by_bookmark_count_descending(self):
        tag_few = self.setup_tag(name="few_bookmarks")
        tag_many = self.setup_tag(name="many_bookmarks")
        tag_none = self.setup_tag(name="no_bookmarks")

        self.setup_bookmark(tags=[tag_few])
        self.setup_bookmark(tags=[tag_many])
        self.setup_bookmark(tags=[tag_many])
        self.setup_bookmark(tags=[tag_many])

        response = self.client.get(reverse("linkding:tags.index") + "?sort=count-desc")

        self.assertOrderedRows(response, [tag_many, tag_few, tag_none])

    def test_default_sort_is_name_ascending(self):
        tag_c = self.setup_tag(name="c_tag")
        tag_a = self.setup_tag(name="a_tag")
        tag_b = self.setup_tag(name="b_tag")

        response = self.client.get(reverse("linkding:tags.index"))

        self.assertOrderedRows(response, [tag_a, tag_b, tag_c])

    def test_sort_select_has_correct_options_and_selection(self):
        self.setup_tag()

        response = self.client.get(reverse("linkding:tags.index"))
        html = response.content.decode()

        self.assertInHTML(
            """
            <select id="sort" name="sort" class="form-select" data-submit-on-change>
              <option value="name-asc" selected>Name A-Z</option>
              <option value="name-desc">Name Z-A</option>
              <option value="count-asc">Fewest bookmarks</option>
              <option value="count-desc">Most bookmarks</option>
            </select>        
        """,
            html,
        )

        response = self.client.get(reverse("linkding:tags.index") + "?sort=name-desc")
        html = response.content.decode()

        self.assertInHTML(
            """
            <select id="sort" name="sort" class="form-select" data-submit-on-change>
              <option value="name-asc">Name A-Z</option>
              <option value="name-desc" selected>Name Z-A</option>
              <option value="count-asc">Fewest bookmarks</option>
              <option value="count-desc">Most bookmarks</option>
            </select>        
        """,
            html,
        )


================================================
FILE: bookmarks/tests/test_tags_merge_view.py
================================================
from bs4 import TemplateString
from bs4.element import CData, NavigableString
from django.test import TestCase
from django.urls import reverse

from bookmarks.models import Bookmark, Tag
from bookmarks.tests.helpers import BookmarkFactoryMixin, HtmlTestMixin


class TagsMergeViewTestCase(TestCase, BookmarkFactoryMixin, HtmlTestMixin):
    def setUp(self) -> None:
        self.user = self.get_or_create_test_user()
        self.client.force_login(self.user)

    def get_text(self, element):
        # Invalid form responses are wrapped in <template> tags, which BeautifulSoup
        # treats as TemplateString objects. Include those when extracting text.
        return element.get_text(types=(NavigableString, CData, TemplateString))

    def get_form_group(self, response, input_name):
        soup = self.make_soup(response.content.decode())
        input_element = soup.find("input", {"name": input_name})
        if input_element:
            return input_element.find_parent("div", class_="form-group")
        autocomplete_element = soup.find(
            "ld-tag-autocomplete", {"input-name": input_name}
        )
        if autocomplete_element:
            return autocomplete_element.find_parent("div", class_="form-group")
        return None

    def get_autocomplete(self, response, input_name):
        soup = self.make_soup(response.content.decode())
        return soup.find("ld-tag-autocomplete", {"input-name": input_name})

    def test_merge_tags(self):
        target_tag = self.setup_tag(name="target_tag")
        merge_tag1 = self.setup_tag(name="merge_tag1")
        merge_tag2 = self.setup_tag(name="merge_tag2")

        bookmark1 = self.setup_bookmark(tags=[merge_tag1])
        bookmark2 = self.setup_bookmark(tags=[merge_tag2])
        bookmark3 = self.setup_bookmark(tags=[target_tag])

        response = self.client.post(
            reverse("linkding:tags.merge"),
            {"target_tag": "target_tag", "merge_tags": "merge_tag1 merge_tag2"},
        )

        self.assertRedirects(response, reverse("linkding:tags.index"))

        self.assertEqual(Tag.objects.count(), 1)
        self.assertFalse(Tag.objects.filter(id=merge_tag1.id).exists())
        self.assertFalse(Tag.objects.filter(id=merge_tag2.id).exists())

        self.assertCountEqual(list(bookmark1.tags.all()), [target_tag])
        self.assertCountEqual(list(bookmark2.tags.all()), [target_tag])
        self.assertCountEqual(list(bookmark3.tags.all()), [target_tag])

    def test_merge_tags_complex(self):
        target_tag = self.setup_tag(name="target_tag")
        merge_tag1 = self.setup_tag(name="merge_tag1")
        merge_tag2 = self.setup_tag(name="merge_tag2")
        other_tag = self.setup_tag(name="other_tag")

        bookmark1 = self.setup_bookmark(tags=[merge_tag1])
        bookmark2 = self.setup_bookmark(tags=[merge_tag2])
        bookmark3 = self.setup_bookmark(tags=[target_tag])
        bookmark4 = self.setup_bookmark(
            tags=[merge_tag1, merge_tag2]
        )  # both merge tags
        bookmark5 = self.setup_bookmark(
            tags=[merge_tag2, target_tag]
        )  # already has target tag
        bookmark6 = self.setup_bookmark(
            tags=[merge_tag1, merge_tag2, target_tag]
        )  # both merge tags and target
        bookmark7 = self.setup_bookmark(tags=[other_tag])  # unrelated tag
        bookmark8 = self.setup_bookmark(
            tags=[other_tag, merge_tag1]
        )  # merge and unrelated tag
        bookmark9 = self.setup_bookmark(
            tags=[other_tag, target_tag]
        )  # merge and target tag
        bookmark10 = self.setup_bookmark(tags=[])  # no tags

        response = self.client.post(
            reverse("linkding:tags.merge"),
            {"target_tag": "target_tag", "merge_tags": "merge_tag1 merge_tag2"},
        )

        self.assertRedirects(response, reverse("linkding:tags.index"))

        self.assertEqual(Bookmark.objects.count(), 10)
        self.assertEqual(Tag.objects.count(), 2)
        self.assertEqual(Bookmark.tags.through.objects.count(), 11)

        self.assertCountEqual(list(Tag.objects.all()), [target_tag, other_tag])

        self.assertCountEqual(list(bookmark1.tags.all()), [target_tag])
        self.assertCountEqual(list(bookmark2.tags.all()), [target_tag])
        self.assertCountEqual(list(bookmark3.tags.all()), [target_tag])
        self.assertCountEqual(list(bookmark4.tags.all()), [target_tag])
        self.assertCountEqual(list(bookmark5.tags.all()), [target_tag])
        self.assertCountEqual(list(bookmark6.tags.all()), [target_tag])
        self.assertCountEqual(list(bookmark7.tags.all()), [other_tag])
        self.assertCountEqual(list(bookmark8.tags.all()), [other_tag, target_tag])
        self.assertCountEqual(list(bookmark9.tags.all()), [other_tag, target_tag])
        self.assertCountEqual(list(bookmark10.tags.all()), [])

    def test_can_only_merge_own_tags(self):
        other_user = self.setup_user()
        self.setup_tag(name="target_tag", user=other_user)
        self.setup_tag(name="merge_tag", user=other_user)

        response = self.client.post(
            reverse("linkding:tags.merge"),
            {"target_tag": "target_tag", "merge_tags": "merge_tag"},
        )

        target_tag_group = self.get_form_group(response, "target_tag")
        self.assertIn(
            'Tag "target_tag" does not exist', self.get_text(target_tag_group)
        )

        merge_tags_group = self.get_form_group(response, "merge_tags")
        self.assertIn('Tag "merge_tag" does not exist', self.get_text(merge_tags_group))

    def test_validate_missing_target_tag(self):
        merge_tag = self.setup_tag(name="merge_tag")

        response = self.client.post(
            reverse("linkding:tags.merge"),
            {"target_tag": "", "merge_tags": "merge_tag"},
        )

        target_tag_group = self.get_form_group(response, "target_tag")
        self.assertIn("This field is required", self.get_text(target_tag_group))
        self.assertTrue(Tag.objects.filter(id=merge_tag.id).exists())

        autocomplete = self.get_autocomplete(response, "target_tag")
        self.assertIn("is-error", autocomplete.get("input-class", ""))

    def test_validate_missing_merge_tags(self):
        self.setup_tag(name="target_tag")

        response = self.client.post(
            reverse("linkding:tags.merge"),
            {"target_tag": "target_tag", "merge_tags": ""},
        )

        merge_tags_group = self.get_form_group(response, "merge_tags")
        self.assertIn("This field is required", self.get_text(merge_tags_group))

        autocomplete = self.get_autocomplete(response, "merge_tags")
        self.assertIn("is-error", autocomplete.get("input-class", ""))

    def test_validate_nonexistent_target_tag(self):
        self.setup_tag(name="merge_tag")

        response = self.client.post(
            reverse("linkding:tags.merge"),
            {"target_tag": "nonexistent_tag", "merge_tags": "merge_tag"},
        )

        target_tag_group = self.get_form_group(response, "target_tag")
        self.assertIn(
            'Tag "nonexistent_tag" does not exist', self.get_text(target_tag_group)
        )

    def test_validate_nonexistent_merge_tag(self):
        self.setup_tag(name="target_tag")
        self.setup_tag(name="merge_tag1")

        response = self.client.post(
            reverse("linkding:tags.merge"),
            {"target_tag": "target_tag", "merge_tags": "merge_tag1 nonexistent_tag"},
        )

        merge_tags_group = self.get_form_group(response, "merge_tags")
        self.assertIn(
            'Tag "nonexistent_tag" does not exist', self.get_text(merge_tags_group)
        )

    def test_validate_multiple_target_tags(self):
        self.setup_tag(name="target_tag1")
        self.setup_tag(name="target_tag2")

        response = self.client.post(
            reverse("linkding:tags.merge"),
            {"target_tag": "target_tag1 target_tag2", "merge_tags": "some_tag"},
        )

        target_tag_group = self.get_form_group(response, "target_tag")
        self.assertIn(
            "Please enter only one tag name for the target tag",
            self.get_text(target_tag_group),
        )

    def test_validate_target_tag_in_merge_list(self):
        self.setup_tag(name="target_tag")
        self.setup_tag(name="merge_tag")

        response = self.client.post(
            reverse("linkding:tags.merge"),
            {"target_tag": "target_tag", "merge_tags": "target_tag merge_tag"},
        )

        merge_tags_group = self.get_form_group(response, "merge_tags")
        self.assertIn(
            "The target tag cannot be selected for merging",
            self.get_text(merge_tags_group),
        )

    def test_merge_shows_success_message(self):
        self.setup_tag(name="target_tag")
        self.setup_tag(name="merge_tag1")
        self.setup_tag(name="merge_tag2")

        response = self.client.post(
            reverse("linkding:tags.merge"),
            {"target_tag": "target_tag", "merge_tags": "merge_tag1 merge_tag2"},
            follow=True,
        )

        self.assertInHTML(
            """
                <div class="toast toast-success" role="alert">
                    Successfully merged 2 tags (merge_tag1, merge_tag2) into "target_tag".
                </div>
            """,
            response.content.decode(),
        )


================================================
FILE: bookmarks/tests/test_tags_model.py
================================================
from django.test import TestCase

from bookmarks.models import parse_tag_string


class TagTestCase(TestCase):
    def test_parse_tag_string_returns_list_of_tag_names(self):
        self.assertCountEqual(
            parse_tag_string("book, movie, album"), ["book", "movie", "album"]
        )

    def test_parse_tag_string_respects_separator(self):
        self.assertCountEqual(
            parse_tag_string("book movie album", " "), ["book", "movie", "album"]
        )

    def test_parse_tag_string_orders_tag_names_alphabetically(self):
        self.assertListEqual(
            parse_tag_string("book,movie,album"), ["album", "book", "movie"]
        )
        self.assertListEqual(
            parse_tag_string("Book,movie,album"), ["album", "Book", "movie"]
        )

    def test_parse_tag_string_handles_whitespace(self):
        self.assertCountEqual(
            parse_tag_string("\t  book, movie \t, album, \n\r"),
            ["album", "book", "movie"],
        )

    def test_parse_tag_string_handles_invalid_input(self):
        self.assertListEqual(parse_tag_string(None), [])
        self.assertListEqual(parse_tag_string(""), [])

    def test_parse_tag_string_deduplicates_tag_names(self):
        self.assertEqual(len(parse_tag_string("book,book,Book,BOOK")), 1)

    def test_parse_tag_string_handles_duplicate_separators(self):
        self.assertCountEqual(
            parse_tag_string("book,,movie,,,album"), ["album", "book", "movie"]
        )

    def test_parse_tag_string_handles_duplicate_separators_with_spaces(self):
        self.assertCountEqual(
            parse_tag_string("book, ,movie, , ,album"), ["album", "book", "movie"]
        )

    def test_parse_tag_string_replaces_whitespace_within_names(self):
        self.assertCountEqual(
            parse_tag_string("travel guide, book recommendations"),
            ["travel-guide", "book-recommendations"],
        )


================================================
FILE: bookmarks/tests/test_tags_new_view.py
================================================
from django.test import TestCase
from django.urls import reverse

from bookmarks.models import Tag
from bookmarks.tests.helpers import BookmarkFactoryMixin


class TagsNewViewTestCase(TestCase, BookmarkFactoryMixin):
    def setUp(self) -> None:
        self.user = self.get_or_create_test_user()
        self.client.force_login(self.user)

    def test_create_tag(self):
        response = self.client.post(reverse("linkding:tags.new"), {"name": "new_tag"})

        self.assertRedirects(response, reverse("linkding:tags.index"))
        self.assertEqual(Tag.objects.count(), 1)
        self.assertTrue(Tag.objects.filter(name="new_tag", owner=self.user).exists())

    def test_show_error_for_empty_name(self):
        response = self.client.post(reverse("linkding:tags.new"), {"name": ""})

        self.assertContains(response, "This field is required")
        self.assertEqual(Tag.objects.count(), 0)

    def test_show_error_for_duplicate_name(self):
        self.setup_tag(name="existing_tag")

        response = self.client.post(
            reverse("linkding:tags.new"), {"name": "existing_tag"}
        )

        self.assertContains(response, "Tag &quot;existing_tag&quot; already exists")
        self.assertEqual(Tag.objects.count(), 1)

    def test_show_error_for_duplicate_name_different_casing(self):
        self.setup_tag(name="existing_tag")

        response = self.client.post(
            reverse("linkding:tags.new"), {"name": "existing_TAG"}
        )

        self.assertContains(response, "Tag &quot;existing_TAG&quot; already exists")
        self.assertEqual(Tag.objects.count(), 1)

    def test_no_error_for_duplicate_name_different_user(self):
        other_user = self.setup_user()
        self.setup_tag(name="existing_tag", user=other_user)

        response = self.client.post(
            reverse("linkding:tags.new"), {"name": "existing_tag"}
        )

        self.assertRedirects(response, reverse("linkding:tags.index"))
        self.assertEqual(Tag.objects.count(), 2)
        self.assertEqual(
            Tag.objects.filter(name="existing_tag", owner=self.user).count(), 1
        )
        self.assertEqual(
            Tag.objects.filter(name="existing_tag", owner=other_user).count(), 1
        )

    def test_create_shows_success_message(self):
        response = self.client.post(
            reverse("linkding:tags.new"), {"name": "new_tag"}, follow=True
        )

        self.assertInHTML(
            """
            <div class="toast toast-success" role="alert">
                Tag "new_tag" created successfully.
            </div>
        """,
            response.content.decode(),
        )


================================================
FILE: bookmarks/tests/test_tags_service.py
================================================
import datetime

from django.test import TestCase
from django.utils import timezone

from bookmarks.models import Tag
from bookmarks.services.tags import get_or_create_tag, get_or_create_tags
from bookmarks.tests.helpers import BookmarkFactoryMixin


class TagServiceTestCase(TestCase, BookmarkFactoryMixin):
    def setUp(self) -> None:
        self.get_or_create_test_user()

    def test_get_or_create_tag_should_create_new_tag(self):
        get_or_create_tag("Book", self.user)

        tags = Tag.objects.all()

        self.assertEqual(len(tags), 1)
        self.assertEqual(tags[0].name, "Book")
        self.assertEqual(tags[0].owner, self.user)
        self.assertTrue(
            abs(tags[0].date_added - timezone.now()) < datetime.timedelta(seconds=10)
        )

    def test_get_or_create_tag_should_return_existing_tag(self):
        first_tag = get_or_create_tag("Book", self.user)
        second_tag = get_or_create_tag("Book", self.user)

        tags = Tag.objects.all()

        self.assertEqual(len(tags), 1)
        self.assertEqual(first_tag.id, second_tag.id)

    def test_get_or_create_tag_should_ignore_casing_when_looking_for_existing_tag(self):
        first_tag = get_or_create_tag("Book", self.user)
        second_tag = get_or_create_tag("book", self.user)

        tags = Tag.objects.all()

        self.assertEqual(len(tags), 1)
        self.assertEqual(first_tag.id, second_tag.id)

    def test_get_or_create_tag_should_handle_legacy_dbs_with_existing_duplicates(self):
        first_tag = Tag.objects.create(
            name="book", date_added=timezone.now(), owner=self.user
        )
        Tag.objects.create(name="Book", date_added=timezone.now(), owner=self.user)
        retrieved_tag = get_or_create_tag("Book", self.user)

        self.assertEqual(first_tag.id, retrieved_tag.id)

    def test_get_or_create_tags_should_return_tags(self):
        books_tag = get_or_create_tag("Book", self.user)
        movies_tag = get_or_create_tag("Movie", self.user)

        tags = get_or_create_tags(["book", "movie"], self.user)

        self.assertEqual(len(tags), 2)
        self.assertListEqual(tags, [books_tag, movies_tag])

    def test_get_or_create_tags_should_deduplicate_tags(self):
        books_tag = get_or_create_tag("Book", self.user)

        tags = get_or_create_tags(["book", "Book", "BOOK"], self.user)

        self.assertEqual(len(tags), 1)
        self.assertListEqual(tags, [books_tag])


================================================
FILE: bookmarks/tests/test_toasts_view.py
================================================
from django.contrib.auth.models import User
from django.test import TestCase
from django.urls import reverse

from bookmarks.models import Toast
from bookmarks.tests.helpers import (
    BookmarkFactoryMixin,
    HtmlTestMixin,
    disable_logging,
    random_sentence,
)


class ToastsViewTestCase(TestCase, BookmarkFactoryMixin, HtmlTestMixin):
    def setUp(self) -> None:
        user = self.get_or_create_test_user()
        self.client.force_login(user)

    def create_toast(
        self, user: User = None, message: str = None, acknowledged: bool = False
    ):
        if not user:
            user = self.user
        if not message:
            message = random_sentence()

        toast = Toast(
            owner=user, key="test", message=message, acknowledged=acknowledged
        )
        toast.save()
        return toast

    def test_should_render_unacknowledged_toasts(self):
        self.create_toast()
        self.create_toast()
        self.create_toast(acknowledged=True)

        response = self.client.get(reverse("linkding:bookmarks.index"))

        # Should render toasts container
        self.assertContains(response, '<div class="message-list">')
        # Should render two toasts
        self.assertContains(response, '<div class="toast d-flex">', count=2)

    def test_should_not_render_acknowledged_toasts(self):
        self.create_toast(acknowledged=True)
        self.create_toast(acknowledged=True)
        self.create_toast(acknowledged=True)

        response = self.client.get(reverse("linkding:bookmarks.index"))

        # Should not render toasts container
        self.assertContains(response, '<div class="message-list">', count=0)
        # Should not render toasts
        self.assertContains(response, '<div class="toast">', count=0)

    def test_should_not_render_toasts_of_other_users(self):
        other_user = User.objects.create_user(
            "otheruser", "otheruser@example.com", "password123"
        )

        self.create_toast(user=other_user)
        self.create_toast(user=other_user)
        self.create_toast(user=other_user)

        response = self.client.get(reverse("linkding:bookmarks.index"))

        # Should not render toasts container
        self.assertContains(response, '<div class="message-list">', count=0)
        # Should not render toasts
        self.assertContains(response, '<div class="toast">', count=0)

    def test_form_tag(self):
        self.create_toast()
        expected_action = f"{reverse('linkding:toasts.acknowledge')}?return_url={reverse('linkding:bookmarks.index')}"

        response = self.client.get(reverse("linkding:bookmarks.index"))
        soup = self.make_soup(response.content.decode())
        form = soup.find("form", attrs={"action": expected_action, "method": "post"})

        self.assertIsNotNone(form)

    def test_toast_content(self):
        toast = self.create_toast()
        expected_toast = f"""
            <div class="toast d-flex">
                {toast.message}
                <button type="submit" name="toast" value="{toast.id}" class="btn btn-clear"></button>
            </div>        
        """

        response = self.client.get(reverse("linkding:bookmarks.index"))
        html = response.content.decode()

        self.assertInHTML(expected_toast, html)

    def test_acknowledge_toast(self):
        toast = self.create_toast()

        self.client.post(
            reverse("linkding:toasts.acknowledge"),
            {
                "toast": [toast.id],
            },
        )

        toast.refresh_from_db()
        self.assertTrue(toast.acknowledged)

    def test_acknowledge_toast_should_redirect_to_return_url(self):
        toast = self.create_toast()
        return_url = reverse("linkding:settings.general")
        acknowledge_url = reverse("linkding:toasts.acknowledge")
        acknowledge_url = acknowledge_url + "?return_url=" + return_url

        response = self.client.post(
            acknowledge_url,
            {
                "toast": [toast.id],
            },
        )

        self.assertRedirects(response, return_url)

    def test_acknowledge_toast_should_redirect_to_index_by_default(self):
        toast = self.create_toast()

        response = self.client.post(
            reverse("linkding:toasts.acknowledge"),
            {
                "toast": [toast.id],
            },
        )

        self.assertRedirects(response, reverse("linkding:bookmarks.index"))

    @disable_logging
    def test_acknowledge_toast_should_not_acknowledge_other_users_toast(self):
        other_user = User.objects.create_user(
            "otheruser", "otheruser@example.com", "password123"
        )
        toast = self.create_toast(user=other_user)

        response = self.client.post(
            reverse("linkding:toasts.acknowledge"),
            {
                "toast": [toast.id],
            },
        )
        self.assertEqual(response.status_code, 404)


================================================
FILE: bookmarks/tests/test_user_profile_model.py
================================================
from django.contrib.auth.models import User
from django.test import TestCase

from bookmarks.models import UserProfile


class UserProfileTestCase(TestCase):
    def test_create_user_should_init_profile(self):
        user = User.objects.create_user("testuser", "test@example.com", "password123")
        profile = UserProfile.objects.all().filter(user_id=user.id).first()
        self.assertIsNotNone(profile)

    def test_bookmark_sharing_is_disabled_by_default(self):
        user = User.objects.create_user("testuser", "test@example.com", "password123")
        profile = UserProfile.objects.all().filter(user_id=user.id).first()
        self.assertFalse(profile.enable_sharing)


================================================
FILE: bookmarks/tests/test_user_select_tag.py
================================================
from django.template import RequestContext, Template
from django.test import RequestFactory, TestCase

from bookmarks.models import BookmarkSearch, User
from bookmarks.tests.helpers import BookmarkFactoryMixin
from bookmarks.views import contexts


class UserSelectTagTest(TestCase, BookmarkFactoryMixin):
    def render_template(self, url: str):
        rf = RequestFactory()
        request = rf.get(url)
        request.user = self.get_or_create_test_user()
        request.user_profile = self.get_or_create_test_user().profile
        search = BookmarkSearch.from_request(request, request.GET)
        user_list = contexts.UserListContext(request, search)
        context = RequestContext(
            request,
            {
                "request": request,
                "user_list": user_list,
            },
        )
        template_to_render = Template("{% include 'bookmarks/user_section.html' %}")
        return template_to_render.render(context)

    def assertUserOption(self, html: str, user: User, selected: bool = False):
        self.assertInHTML(
            f"""
          <option value="{user.username}" {"selected" if selected else ""}>
            {user.username}
          </option>        
        """,
            html,
        )

    def assertHiddenInput(self, html: str, name: str, value: str = None):
        needle = f'<input type="hidden" name="{name}"'
        if value is not None:
            needle += f' value="{value}"'

        self.assertIn(needle, html)

    def assertNoHiddenInput(self, html: str, name: str):
        needle = f'<input type="hidden" name="{name}"'

        self.assertNotIn(needle, html)

    def test_empty_option(self):
        user1 = self.setup_user(name="user1", enable_sharing=True)
        self.setup_bookmark(user=user1, shared=True)

        rendered_template = self.render_template("/test")

        self.assertInHTML(
            """
          <option value="" selected="">Everyone</option>
        """,
            rendered_template,
        )

    def test_render_user_options(self):
        user1 = self.setup_user(name="user1", enable_sharing=True)
        user2 = self.setup_user(name="user2", enable_sharing=True)
        user3 = self.setup_user(name="user3", enable_sharing=True)

        self.setup_bookmark(user=user1, shared=True)
        self.setup_bookmark(user=user2, shared=True)
        self.setup_bookmark(user=user3, shared=True)

        rendered_template = self.render_template("/test")

        self.assertUserOption(rendered_template, user1)
        self.assertUserOption(rendered_template, user2)
        self.assertUserOption(rendered_template, user3)

    def test_preselect_user_option(self):
        user1 = self.setup_user(name="user1", enable_sharing=True)
        user2 = self.setup_user(name="user2", enable_sharing=True)
        user3 = self.setup_user(name="user3", enable_sharing=True)

        self.setup_bookmark(user=user1, shared=True)
        self.setup_bookmark(user=user2, shared=True)
        self.setup_bookmark(user=user3, shared=True)

        rendered_template = self.render_template("/test?user=user1")

        self.assertUserOption(rendered_template, user1, True)

    def test_hidden_inputs(self):
        # Without params
        url = "/test"
        rendered_template = self.render_template(url)

        self.assertNoHiddenInput(rendered_template, "user")
        self.assertNoHiddenInput(rendered_template, "q")
        self.assertNoHiddenInput(rendered_template, "sort")
        self.assertNoHiddenInput(rendered_template, "shared")
        self.assertNoHiddenInput(rendered_template, "unread")

        # With params
        url = "/test?q=foo&user=john&sort=title_asc&shared=yes&unread=yes"
        rendered_template = self.render_template(url)

        self.assertNoHiddenInput(rendered_template, "user")
        self.assertHiddenInput(rendered_template, "q", "foo")
        self.assertHiddenInput(rendered_template, "sort", "title_asc")
        self.assertHiddenInput(rendered_template, "shared", "yes")
        self.assertHiddenInput(rendered_template, "unread", "yes")


================================================
FILE: bookmarks/tests/test_utils.py
================================================
from unittest.mock import patch

from django.test import TestCase
from django.utils import timezone

from bookmarks.utils import (
    humanize_absolute_date,
    humanize_relative_date,
    normalize_url,
    parse_timestamp,
)


class UtilsTestCase(TestCase):
    def test_humanize_absolute_date(self):
        test_cases = [
            (
                timezone.datetime(2021, 1, 1),
                timezone.datetime(2023, 1, 1),
                "01/01/2021",
            ),
            (
                timezone.datetime(2021, 1, 1),
                timezone.datetime(2021, 2, 1),
                "01/01/2021",
            ),
            (
                timezone.datetime(2021, 1, 1),
                timezone.datetime(2021, 1, 8),
                "01/01/2021",
            ),
            (timezone.datetime(2021, 1, 1), timezone.datetime(2021, 1, 7), "Friday"),
            (
                timezone.datetime(2021, 1, 1),
                timezone.datetime(2021, 1, 7, 23, 59),
                "Friday",
            ),
            (timezone.datetime(2021, 1, 1), timezone.datetime(2021, 1, 3), "Friday"),
            (timezone.datetime(2021, 1, 1), timezone.datetime(2021, 1, 2), "Yesterday"),
            (
                timezone.datetime(2021, 1, 1),
                timezone.datetime(2021, 1, 2, 23, 59),
                "Yesterday",
            ),
            (timezone.datetime(2021, 1, 1), timezone.datetime(2021, 1, 1), "Today"),
        ]

        for test_case in test_cases:
            result = humanize_absolute_date(test_case[0], test_case[1])
            self.assertEqual(test_case[2], result)

    def test_humanize_absolute_date_should_use_current_date_as_default(self):
        with patch.object(timezone, "now", return_value=timezone.datetime(2021, 1, 1)):
            self.assertEqual(
                humanize_absolute_date(timezone.datetime(2021, 1, 1)), "Today"
            )

        # Regression: Test that subsequent calls use current date instead of cached date (#107)
        with patch.object(timezone, "now", return_value=timezone.datetime(2021, 1, 13)):
            self.assertEqual(
                humanize_absolute_date(timezone.datetime(2021, 1, 13)), "Today"
            )

    def test_humanize_relative_date(self):
        test_cases = [
            (
                timezone.datetime(2021, 1, 1),
                timezone.datetime(2022, 1, 1),
                "1 year ago",
            ),
            (
                timezone.datetime(2021, 1, 1),
                timezone.datetime(2022, 12, 31),
                "1 year ago",
            ),
            (
                timezone.datetime(2021, 1, 1),
                timezone.datetime(2023, 1, 1),
                "2 years ago",
            ),
            (
                timezone.datetime(2021, 1, 1),
                timezone.datetime(2023, 12, 31),
                "2 years ago",
            ),
            (
                timezone.datetime(2021, 1, 1),
                timezone.datetime(2021, 12, 31),
                "11 months ago",
            ),
            (
                timezone.datetime(2021, 1, 1),
                timezone.datetime(2021, 2, 1),
                "1 month ago",
            ),
            (
                timezone.datetime(2021, 1, 1),
                timezone.datetime(2021, 1, 31),
                "4 weeks ago",
            ),
            (
                timezone.datetime(2021, 1, 1),
                timezone.datetime(2021, 1, 14),
                "1 week ago",
            ),
            (
                timezone.datetime(2021, 1, 1),
                timezone.datetime(2021, 1, 8),
                "1 week ago",
            ),
            (timezone.datetime(2021, 1, 1), timezone.datetime(2021, 1, 7), "Friday"),
            (
                timezone.datetime(2021, 1, 1),
                timezone.datetime(2021, 1, 7, 23, 59),
                "Friday",
            ),
            (timezone.datetime(2021, 1, 1), timezone.datetime(2021, 1, 3), "Friday"),
            (timezone.datetime(2021, 1, 1), timezone.datetime(2021, 1, 2), "Yesterday"),
            (
                timezone.datetime(2021, 1, 1),
                timezone.datetime(2021, 1, 2, 23, 59),
                "Yesterday",
            ),
            (timezone.datetime(2021, 1, 1), timezone.datetime(2021, 1, 1), "Today"),
        ]

        for test_case in test_cases:
            result = humanize_relative_date(test_case[0], test_case[1])
            self.assertEqual(test_case[2], result)

    def test_humanize_relative_date_should_use_current_date_as_default(self):
        with patch.object(timezone, "now", return_value=timezone.datetime(2021, 1, 1)):
            self.assertEqual(
                humanize_relative_date(timezone.datetime(2021, 1, 1)), "Today"
            )

        # Regression: Test that subsequent calls use current date instead of cached date (#107)
        with patch.object(timezone, "now", return_value=timezone.datetime(2021, 1, 13)):
            self.assertEqual(
                humanize_relative_date(timezone.datetime(2021, 1, 13)), "Today"
            )

    def verify_timestamp(self, date, factor=1):
        timestamp_string = str(int(date.timestamp() * factor))
        parsed_date = parse_timestamp(timestamp_string)
        self.assertEqual(date, parsed_date)

    def test_parse_timestamp_fails_for_invalid_timestamps(self):
        with self.assertRaises(ValueError):
            parse_timestamp("invalid")

    def test_parse_timestamp_parses_millisecond_timestamps(self):
        now = timezone.now().replace(microsecond=0)
        self.verify_timestamp(now)

    def test_parse_timestamp_parses_microsecond_timestamps(self):
        now = timezone.now().replace(microsecond=0)
        self.verify_timestamp(now, 1000)

    def test_parse_timestamp_parses_nanosecond_timestamps(self):
        now = timezone.now().replace(microsecond=0)
        self.verify_timestamp(now, 1000000)

    def test_parse_timestamp_fails_for_out_of_range_timestamp(self):
        now = timezone.now().replace(microsecond=0)

        with self.assertRaises(ValueError):
            self.verify_timestamp(now, 1000000000)

    def test_normalize_url_trailing_slash_handling(self):
        test_cases = [
            ("https://example.com/", "https://example.com"),
            (
                "https://example.com/path/",
                "https://example.com/path",
            ),
            ("https://example.com/path/to/page/", "https://example.com/path/to/page"),
            (
                "https://example.com/path",
                "https://example.com/path",
            ),
        ]

        for original, expected in test_cases:
            with self.subTest(url=original):
                result = normalize_url(original)
                self.assertEqual(expected, result)

    def test_normalize_url_query_parameters(self):
        test_cases = [
            ("https://example.com?z=1&a=2", "https://example.com?a=2&z=1"),
            ("https://example.com?c=3&b=2&a=1", "https://example.com?a=1&b=2&c=3"),
            ("https://example.com?param=value", "https://example.com?param=value"),
            ("https://example.com?", "https://example.com"),
            (
                "https://example.com?empty=&filled=value",
                "https://example.com?empty=&filled=value",
            ),
        ]

        for original, expected in test_cases:
            with self.subTest(url=original):
                result = normalize_url(original)
                self.assertEqual(expected, result)

    def test_normalize_url_case_sensitivity(self):
        test_cases = [
            (
                "https://EXAMPLE.com/Path/To/Page",
                "https://example.com/Path/To/Page",
            ),
            ("https://EXAMPLE.COM/API/v1/Users", "https://example.com/API/v1/Users"),
            (
                "HTTPS://EXAMPLE.COM/path",
                "https://example.com/path",
            ),
        ]

        for original, expected in test_cases:
            with self.subTest(url=original):
                result = normalize_url(original)
                self.assertEqual(expected, result)

    def test_normalize_url_special_characters_and_encoding(self):
        test_cases = [
            (
                "https://example.com/path%20with%20spaces",
                "https://example.com/path%20with%20spaces",
            ),
            ("https://example.com/caf%C3%A9", "https://example.com/caf%C3%A9"),
            (
                "https://example.com/path?q=hello%20world",
                "https://example.com/path?q=hello%20world",
            ),
            ("https://example.com/pàth", "https://example.com/pàth"),
        ]

        for original, expected in test_cases:
            with self.subTest(url=original):
                result = normalize_url(original)
                self.assertEqual(expected, result)

    def test_normalize_url_various_protocols(self):
        test_cases = [
            ("FTP://example.com", "ftp://example.com"),
            ("HTTP://EXAMPLE.COM", "http://example.com"),
            ("https://example.com", "https://example.com"),
            ("file:///path/to/file", "file:///path/to/file"),
        ]

        for original, expected in test_cases:
            with self.subTest(url=original):
                result = normalize_url(original)
                self.assertEqual(expected, result)

    def test_normalize_url_port_handling(self):
        test_cases = [
            ("https://example.com:8080", "https://example.com:8080"),
            ("https://EXAMPLE.COM:8080", "https://example.com:8080"),
            ("http://example.com:80", "http://example.com:80"),
            ("https://example.com:443", "https://example.com:443"),
        ]

        for original, expected in test_cases:
            with self.subTest(url=original):
                result = normalize_url(original)
                self.assertEqual(expected, result)

    def test_normalize_url_authentication_handling(self):
        test_cases = [
            ("https://user:pass@EXAMPLE.COM", "https://user:pass@example.com"),
            ("https://user@EXAMPLE.COM", "https://user@example.com"),
            ("ftp://admin:secret@EXAMPLE.COM", "ftp://admin:secret@example.com"),
        ]

        for original, expected in test_cases:
            with self.subTest(url=original):
                result = normalize_url(original)
                self.assertEqual(expected, result)

    def test_normalize_url_fragment_handling(self):
        test_cases = [
            ("https://example.com#", "https://example.com"),
            ("https://example.com#section", "https://example.com#section"),
            ("https://EXAMPLE.COM/path#Section", "https://example.com/path#Section"),
            ("https://EXAMPLE.COM/path/#Section", "https://example.com/path#Section"),
            ("https://example.com?a=1#fragment", "https://example.com?a=1#fragment"),
            (
                "https://example.com?z=2&a=1#fragment",
                "https://example.com?a=1&z=2#fragment",
            ),
        ]

        for original, expected in test_cases:
            with self.subTest(url=original):
                result = normalize_url(original)
                self.assertEqual(expected, result)

    def test_normalize_url_edge_cases(self):
        test_cases = [
            ("", ""),
            ("   ", ""),
            ("   https://example.com   ", "https://example.com"),
            ("not-a-url", "not-a-url"),
            ("://invalid", "://invalid"),
        ]

        for original, expected in test_cases:
            with self.subTest(url=original):
                result = normalize_url(original)
                self.assertEqual(expected, result)

    def test_normalize_url_internationalized_domain_names(self):
        test_cases = [
            (
                "https://xn--fsq.xn--0zwm56d",
                "https://xn--fsq.xn--0zwm56d",
            ),
            ("https://测试.中国", "https://测试.中国"),
        ]

        for original, expected in test_cases:
            with self.subTest(url=original):
                result = normalize_url(original)
                self.assertEqual(expected.lower() if expected else expected, result)

    def test_normalize_url_complex_query_parameters(self):
        test_cases = [
            (
                "https://example.com?z=1&a=2&z=3&b=4",
                "https://example.com?a=2&b=4&z=1&z=3",  # Multiple values for same key
            ),
            (
                "https://example.com?param=value1&param=value2",
                "https://example.com?param=value1&param=value2",
            ),
            (
                "https://example.com?special=%21%40%23%24%25",
                "https://example.com?special=%21%40%23%24%25",
            ),
        ]

        for original, expected in test_cases:
            with self.subTest(url=original):
                result = normalize_url(original)
                self.assertEqual(expected, result)


================================================
FILE: bookmarks/tests/test_website_loader.py
================================================
from unittest import mock

from django.test import TestCase

from bookmarks.services import website_loader


class MockStreamingResponse:
    def __init__(self, num_chunks, chunk_size, insert_head_after_chunk=None):
        self.chunks = []
        for index in range(num_chunks):
            chunk = "".zfill(chunk_size)
            self.chunks.append(chunk.encode("utf-8"))

            if index == insert_head_after_chunk:
                self.chunks.append(b"</head>")

    def iter_content(self, **kwargs):
        return self.chunks

    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        pass


class WebsiteLoaderTestCase(TestCase):
    def setUp(self):
        # clear cached metadata before test run
        website_loader._load_website_metadata_cached.cache_clear()

    def render_html_document(
        self, title, description="", og_description="", og_image=""
    ):
        meta_description = (
            f'<meta name="description" content="{description}">' if description else ""
        )
        meta_og_description = (
            f'<meta property="og:description" content="{og_description}">'
            if og_description
            else ""
        )
        meta_og_image = (
            f'<meta property="og:image" content="{og_image}">' if og_image else ""
        )
        return f"""
        <!DOCTYPE html>
        <html lang="en">
        <head>
            <meta charset="UTF-8">
            <title>{title}</title>
            {meta_description}
            {meta_og_description}
            {meta_og_image}
        </head>
        <body></body>
        </html>
        """

    def test_load_page_returns_content(self):
        with mock.patch("requests.get") as mock_get:
            mock_get.return_value = MockStreamingResponse(
                num_chunks=10, chunk_size=1024
            )
            content = website_loader.load_page("https://example.com")

            expected_content_size = 10 * 1024
            self.assertEqual(expected_content_size, len(content))

    def test_load_page_limits_large_documents(self):
        with mock.patch("requests.get") as mock_get:
            mock_get.return_value = MockStreamingResponse(
                num_chunks=10, chunk_size=1024 * 1000
            )
            content = website_loader.load_page("https://example.com")

            # Should have read six chunks, after which content exceeds the max of 5MB
            expected_content_size = 6 * 1024 * 1000
            self.assertEqual(expected_content_size, len(content))

    def test_load_page_stops_reading_at_end_of_head(self):
        with mock.patch("requests.get") as mock_get:
            mock_get.return_value = MockStreamingResponse(
                num_chunks=10, chunk_size=1024 * 1000, insert_head_after_chunk=0
            )
            content = website_loader.load_page("https://example.com")

            # Should have read first chunk, and second chunk containing closing head tag
            expected_content_size = 1 * 1024 * 1000 + len("</head>")
            self.assertEqual(expected_content_size, len(content))

    def test_load_page_removes_bytes_after_end_of_head(self):
        with mock.patch("requests.get") as mock_get:
            mock_response = MockStreamingResponse(num_chunks=1, chunk_size=0)
            mock_response.chunks[0] = "<head>人</head>".encode()
            # add a single byte that can't be decoded to utf-8
            mock_response.chunks[0] += 0xFF.to_bytes(1, "big")
            mock_get.return_value = mock_response
            content = website_loader.load_page("https://example.com")

            # verify that byte after head was removed, content parsed as utf-8
            self.assertEqual(content, "<head>人</head>")

    def test_load_website_metadata(self):
        with mock.patch(
            "bookmarks.services.website_loader.load_page"
        ) as mock_load_page:
            mock_load_page.return_value = self.render_html_document(
                "test title", "test description"
            )
            metadata = website_loader.load_website_metadata("https://example.com")
            self.assertEqual("test title", metadata.title)
            self.assertEqual("test description", metadata.description)
            self.assertIsNone(metadata.preview_image)

    def test_load_website_metadata_trims_title_and_description(self):
        with mock.patch(
            "bookmarks.services.website_loader.load_page"
        ) as mock_load_page:
            mock_load_page.return_value = self.render_html_document(
                "  test title  ", "  test description  "
            )
            metadata = website_loader.load_website_metadata("https://example.com")
            self.assertEqual("test title", metadata.title)
            self.assertEqual("test description", metadata.description)

    def test_load_website_metadata_using_og_description(self):
        with mock.patch(
            "bookmarks.services.website_loader.load_page"
        ) as mock_load_page:
            mock_load_page.return_value = self.render_html_document(
                "test title", "", og_description="test og description"
            )
            metadata = website_loader.load_website_metadata("https://example.com")
            self.assertEqual("test title", metadata.title)
            self.assertEqual("test og description", metadata.description)

    def test_load_website_metadata_using_og_image(self):
        with mock.patch(
            "bookmarks.services.website_loader.load_page"
        ) as mock_load_page:
            mock_load_page.return_value = self.render_html_document(
                "test title", og_image="http://example.com/image.jpg"
            )
            metadata = website_loader.load_website_metadata("https://example.com")
            self.assertEqual("http://example.com/image.jpg", metadata.preview_image)

    def test_load_website_metadata_gets_absolute_og_image_path_when_path_starts_with_dots(
        self,
    ):
        with mock.patch(
            "bookmarks.services.website_loader.load_page"
        ) as mock_load_page:
            mock_load_page.return_value = self.render_html_document(
                "test title", og_image="../image.jpg"
            )
            metadata = website_loader.load_website_metadata(
                "https://example.com/a/b/page.html"
            )
            self.assertEqual("https://example.com/a/image.jpg", metadata.preview_image)

    def test_load_website_metadata_gets_absolute_og_image_path_when_path_starts_with_slash(
        self,
    ):
        with mock.patch(
            "bookmarks.services.website_loader.load_page"
        ) as mock_load_page:
            mock_load_page.return_value = self.render_html_document(
                "test title", og_image="/image.jpg"
            )
            metadata = website_loader.load_website_metadata(
                "https://example.com/a/b/page.html"
            )
            self.assertEqual("https://example.com/image.jpg", metadata.preview_image)

    def test_load_website_metadata_prefers_description_over_og_description(self):
        with mock.patch(
            "bookmarks.services.website_loader.load_page"
        ) as mock_load_page:
            mock_load_page.return_value = self.render_html_document(
                "test title", "test description", og_description="test og description"
            )
            metadata = website_loader.load_website_metadata("https://example.com")
            self.assertEqual("test title", metadata.title)
            self.assertEqual("test description", metadata.description)

    def test_website_metadata_ignore_cache(self):
        expected_html = '<html><head><title>Test Title</title><meta name="description" content="Test Description"><meta property="og:image" content="/images/test.jpg"></head></html>'

        with mock.patch.object(
            website_loader, "load_page", return_value=expected_html
        ) as mock_load_page:
            website_loader.load_website_metadata("https://example.com")
            mock_load_page.assert_called_once()

            website_loader.load_website_metadata("https://example.com")
            mock_load_page.assert_called_once()

            website_loader.load_website_metadata(
                "https://example.com", ignore_cache=True
            )
            self.assertEqual(mock_load_page.call_count, 2)


class ContentTypeDetectionTestCase(TestCase):
    def test_detect_content_type_returns_content_type_from_head_request(self):
        with mock.patch("requests.head") as mock_head:
            mock_response = mock.Mock()
            mock_response.status_code = 200
            mock_response.headers = {"Content-Type": "application/pdf"}
            mock_head.return_value = mock_response

            result = website_loader.detect_content_type("https://example.com/doc.pdf")

            self.assertEqual(result, "application/pdf")
            mock_head.assert_called_once()

    def test_detect_content_type_strips_charset(self):
        with mock.patch("requests.head") as mock_head:
            mock_response = mock.Mock()
            mock_response.status_code = 200
            mock_response.headers = {"Content-Type": "text/html; charset=utf-8"}
            mock_head.return_value = mock_response

            result = website_loader.detect_content_type("https://example.com")

            self.assertEqual(result, "text/html")

    def test_detect_content_type_returns_lowercase(self):
        with mock.patch("requests.head") as mock_head:
            mock_response = mock.Mock()
            mock_response.status_code = 200
            mock_response.headers = {"Content-Type": "Application/PDF"}
            mock_head.return_value = mock_response

            result = website_loader.detect_content_type("https://example.com/doc.pdf")

            self.assertEqual(result, "application/pdf")

    def test_detect_content_type_falls_back_to_get_when_head_fails(self):
        with (
            mock.patch("requests.head") as mock_head,
            mock.patch("requests.get") as mock_get,
        ):
            import requests

            mock_head.side_effect = requests.RequestException("HEAD failed")

            mock_response = mock.Mock()
            mock_response.status_code = 200
            mock_response.headers = {"Content-Type": "application/pdf"}
            mock_response.__enter__ = mock.Mock(return_value=mock_response)
            mock_response.__exit__ = mock.Mock(return_value=False)
            mock_get.return_value = mock_response

            result = website_loader.detect_content_type("https://example.com/doc.pdf")

            self.assertEqual(result, "application/pdf")
            mock_head.assert_called_once()
            mock_get.assert_called_once()

    def test_detect_content_type_returns_none_when_both_head_and_get_fail(self):
        with (
            mock.patch("requests.head") as mock_head,
            mock.patch("requests.get") as mock_get,
        ):
            import requests

            mock_head.side_effect = requests.RequestException("HEAD failed")
            mock_get.side_effect = requests.RequestException("GET failed")

            result = website_loader.detect_content_type("https://example.com/doc.pdf")

            self.assertIsNone(result)

    def test_detect_content_type_returns_none_for_non_200_status(self):
        with (
            mock.patch("requests.head") as mock_head,
            mock.patch("requests.get") as mock_get,
        ):
            mock_head_response = mock.Mock()
            mock_head_response.status_code = 404
            mock_head.return_value = mock_head_response

            mock_get_response = mock.Mock()
            mock_get_response.status_code = 404
            mock_get_response.__enter__ = mock.Mock(return_value=mock_get_response)
            mock_get_response.__exit__ = mock.Mock(return_value=False)
            mock_get.return_value = mock_get_response

            result = website_loader.detect_content_type("https://example.com/doc.pdf")

            self.assertIsNone(result)

    def test_is_pdf_content_type(self):
        self.assertTrue(website_loader.is_pdf_content_type("application/pdf"))
        self.assertTrue(website_loader.is_pdf_content_type("application/x-pdf"))
        self.assertFalse(website_loader.is_pdf_content_type("text/html"))
        self.assertFalse(website_loader.is_pdf_content_type(None))
        self.assertFalse(website_loader.is_pdf_content_type(""))


================================================
FILE: bookmarks/tests_e2e/__init__.py
================================================


================================================
FILE: bookmarks/tests_e2e/e2e_test_a11y_navigation_focus.py
================================================
from django.urls import reverse
from playwright.sync_api import expect

from bookmarks.tests_e2e.helpers import LinkdingE2ETestCase


class A11yNavigationFocusTest(LinkdingE2ETestCase):
    def test_initial_page_load_focus(self):
        # First page load should keep focus on the body
        page = self.open(reverse("linkding:bookmarks.index"))
        focused_tag = page.evaluate("document.activeElement?.tagName")
        self.assertEqual("BODY", focused_tag)

        page.goto(self.live_server_url + reverse("linkding:bookmarks.archived"))
        focused_tag = page.evaluate("document.activeElement?.tagName")
        self.assertEqual("BODY", focused_tag)

        page.goto(self.live_server_url + reverse("linkding:settings.general"))
        focused_tag = page.evaluate("document.activeElement?.tagName")
        self.assertEqual("BODY", focused_tag)

        # Bookmark form views should focus the URL input
        page.goto(self.live_server_url + reverse("linkding:bookmarks.new"))
        page.wait_for_timeout(timeout=1000)
        focused_tag = page.evaluate(
            "document.activeElement?.tagName + '|' + document.activeElement?.name"
        )
        self.assertEqual("INPUT|url", focused_tag)

    def test_page_navigation_focus(self):
        bookmark = self.setup_bookmark()

        page = self.open(reverse("linkding:bookmarks.index"))

        # Subsequent navigation should move focus to main content
        self.reset_focus()
        self.navigate_menu("Bookmarks", "Active")
        focused = page.locator("main:focus")
        expect(focused).to_be_visible()

        self.reset_focus()
        self.navigate_menu("Bookmarks", "Archived")
        focused = page.locator("main:focus")
        expect(focused).to_be_visible()

        self.reset_focus()
        self.navigate_menu("Settings", "General")
        focused = page.locator("main:focus")
        expect(focused).to_be_visible()

        # Bookmark form views should focus the URL input
        self.reset_focus()
        self.navigate_menu("Add bookmark")
        focused = page.locator("input[name='url']:focus")
        expect(focused).to_be_visible()

        # Opening details modal should move focus to close button
        self.navigate_menu("Bookmarks", "Active")
        self.open_details_modal(bookmark)
        focused = page.locator(".modal button.close:focus")
        expect(focused).to_be_visible()

        # Closing modal should move focus back to the bookmark item
        page.keyboard.press("Escape")
        focused = self.locate_bookmark(bookmark.title).locator("a.view-action:focus")
        expect(focused).to_be_visible()

    def reset_focus(self):
        self.page.evaluate("document.activeElement.blur()")


================================================
FILE: bookmarks/tests_e2e/e2e_test_bookmark_details_modal.py
================================================
from django.test import override_settings
from django.urls import reverse
from playwright.sync_api import expect

from bookmarks.models import Bookmark
from bookmarks.tests_e2e.helpers import LinkdingE2ETestCase


class BookmarkDetailsModalE2ETestCase(LinkdingE2ETestCase):
    def test_show_details(self):
        bookmark = self.setup_bookmark()

        self.open(reverse("linkding:bookmarks.index"))

        details_modal = self.open_details_modal(bookmark)
        title = details_modal.locator("h2")
        expect(title).to_have_text(bookmark.title)

    def test_close_details(self):
        bookmark = self.setup_bookmark()

        self.open(reverse("linkding:bookmarks.index"))

        # close with close button
        details_modal = self.open_details_modal(bookmark)
        details_modal.locator("button.close").click()
        expect(details_modal).to_be_hidden()

        # close with backdrop
        details_modal = self.open_details_modal(bookmark)
        overlay = details_modal.locator(".modal-overlay")
        overlay.click(position={"x": 0, "y": 0})
        expect(details_modal).to_be_hidden()

        # close with escape
        details_modal = self.open_details_modal(bookmark)
        self.page.keyboard.press("Escape")
        expect(details_modal).to_be_hidden()

    def test_toggle_archived(self):
        bookmark = self.setup_bookmark()

        # archive
        url = reverse("linkding:bookmarks.index")
        self.open(url)

        details_modal = self.open_details_modal(bookmark)
        details_modal.get_by_text("Archived", exact=False).click()
        expect(self.locate_bookmark(bookmark.title)).not_to_be_visible()
        self.assertReloads(0)

        # unarchive
        url = reverse("linkding:bookmarks.archived")
        self.page.goto(self.live_server_url + url)
        self.resetReloads()

        details_modal = self.open_details_modal(bookmark)
        details_modal.get_by_text("Archived", exact=False).click()
        expect(self.locate_bookmark(bookmark.title)).not_to_be_visible()
        self.assertReloads(0)

    def test_toggle_unread(self):
        bookmark = self.setup_bookmark()

        # mark as unread
        url = reverse("linkding:bookmarks.index")
        self.open(url)

        details_modal = self.open_details_modal(bookmark)

        details_modal.get_by_text("Unread").click()
        bookmark_item = self.locate_bookmark(bookmark.title)
        expect(bookmark_item.get_by_text("Unread")).to_be_visible()
        self.assertReloads(0)

        # mark as read
        details_modal.get_by_text("Unread").click()
        bookmark_item = self.locate_bookmark(bookmark.title)
        expect(bookmark_item.get_by_text("Unread")).not_to_be_visible()
        self.assertReloads(0)

    def test_toggle_shared(self):
        profile = self.get_or_create_test_user().profile
        profile.enable_sharing = True
        profile.save()

        bookmark = self.setup_bookmark()

        # share bookmark
        url = reverse("linkding:bookmarks.index")
        self.open(url)

        details_modal = self.open_details_modal(bookmark)

        details_modal.get_by_text("Shared").click()
        bookmark_item = self.locate_bookmark(bookmark.title)
        expect(bookmark_item.get_by_text("Shared")).to_be_visible()
        self.assertReloads(0)

        # unshare bookmark
        details_modal.get_by_text("Shared").click()
        bookmark_item = self.locate_bookmark(bookmark.title)
        expect(bookmark_item.get_by_text("Shared")).not_to_be_visible()
        self.assertReloads(0)

    def test_edit_return_url(self):
        bookmark = self.setup_bookmark()

        url = reverse("linkding:bookmarks.index") + f"?q={bookmark.title}"
        self.open(url)

        details_modal = self.open_details_modal(bookmark)

        # Navigate to edit page
        with self.page.expect_navigation():
            details_modal.get_by_text("Edit").click()

        # Cancel edit, verify return to details url
        details_url = url + f"&details={bookmark.id}"
        with self.page.expect_navigation(url=self.live_server_url + details_url):
            self.page.get_by_text("Cancel").click()

    def test_delete(self):
        bookmark = self.setup_bookmark()

        url = reverse("linkding:bookmarks.index") + f"?q={bookmark.title}"
        self.open(url)

        details_modal = self.open_details_modal(bookmark)

        # Wait for confirm button to be initialized
        self.page.wait_for_timeout(1000)

        # Delete bookmark, verify return url
        with self.page.expect_navigation(url=self.live_server_url + url):
            details_modal.get_by_text("Delete").click()
            self.locate_confirm_dialog().get_by_text("Confirm").click()

        # verify bookmark is deleted
        expect(self.locate_bookmark(bookmark.title)).not_to_be_visible()

        self.assertEqual(Bookmark.objects.count(), 0)

    @override_settings(LD_ENABLE_SNAPSHOTS=True)
    def test_create_snapshot_remove_snapshot(self):
        bookmark = self.setup_bookmark()

        url = reverse("linkding:bookmarks.index") + f"?q={bookmark.title}"
        self.open(url)

        details_modal = self.open_details_modal(bookmark)
        asset_list = details_modal.locator(".assets")

        # No snapshots initially
        snapshot = asset_list.get_by_text("snapshot", exact=False)
        expect(snapshot).not_to_be_visible()

        # Create snapshot
        details_modal.get_by_text("snapshot", exact=False).click()
        self.assertReloads(0)

        # Has new snapshots
        expect(snapshot).to_be_visible()

        # Remove snapshot
        asset_list.get_by_text("Remove", exact=False).click()
        self.locate_confirm_dialog().get_by_text("Confirm", exact=False).click()

        # Snapshot is removed
        expect(snapshot).not_to_be_visible()
        self.assertReloads(0)


================================================
FILE: bookmarks/tests_e2e/e2e_test_bookmark_item.py
================================================
from unittest import skip

from django.urls import reverse
from playwright.sync_api import expect

from bookmarks.tests_e2e.helpers import LinkdingE2ETestCase


class BookmarkItemE2ETestCase(LinkdingE2ETestCase):
    @skip("Fails in CI, needs investigation")
    def test_toggle_notes_should_show_hide_notes(self):
        bookmark = self.setup_bookmark(notes="Test notes")

        page = self.open(reverse("linkding:bookmarks.index"))

        notes = self.locate_bookmark(bookmark.title).locator(".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()


================================================
FILE: bookmarks/tests_e2e/e2e_test_bookmark_page_bulk_edit.py
================================================
from django.urls import reverse
from playwright.sync_api import expect

from bookmarks.models import Bookmark
from bookmarks.tests_e2e.helpers import LinkdingE2ETestCase


class BookmarkPageBulkEditE2ETestCase(LinkdingE2ETestCase):
    def setup_test_data(self):
        self.setup_numbered_bookmarks(50)
        self.setup_numbered_bookmarks(50, archived=True)
        self.setup_numbered_bookmarks(50, prefix="foo")
        self.setup_numbered_bookmarks(50, archived=True, prefix="foo")

        self.assertEqual(
            50,
            Bookmark.objects.filter(
                is_archived=False, title__startswith="Bookmark"
            ).count(),
        )
        self.assertEqual(
            50,
            Bookmark.objects.filter(
                is_archived=True, title__startswith="Archived Bookmark"
            ).count(),
        )
        self.assertEqual(
            50,
            Bookmark.objects.filter(is_archived=False, title__startswith="foo").count(),
        )
        self.assertEqual(
            50,
            Bookmark.objects.filter(is_archived=True, title__startswith="foo").count(),
        )

    def test_active_bookmarks_bulk_select_across(self):
        self.setup_test_data()

        self.open(reverse("linkding:bookmarks.index"))

        bookmark_list = self.locate_bookmark_list().element_handle()
        self.locate_bulk_edit_toggle().click()
        self.locate_bulk_edit_select_all().click()
        self.locate_bulk_edit_select_across().click()

        self.select_bulk_action("Delete")
        self.locate_bulk_edit_bar().get_by_text("Execute").click()
        self.locate_confirm_dialog().get_by_text("Confirm").click()
        # Wait until bookmark list is updated (old reference becomes invisible)
        bookmark_list.wait_for_element_state("hidden", timeout=1000)

        self.assertEqual(
            0,
            Bookmark.objects.filter(
                is_archived=False, title__startswith="Bookmark"
            ).count(),
        )
        self.assertEqual(
            50,
            Bookmark.objects.filter(
                is_archived=True, title__startswith="Archived Bookmark"
            ).count(),
        )
        self.assertEqual(
            0,
            Bookmark.objects.filter(is_archived=False, title__startswith="foo").count(),
        )
        self.assertEqual(
            50,
            Bookmark.objects.filter(is_archived=True, title__startswith="foo").count(),
        )

    def test_archived_bookmarks_bulk_select_across(self):
        self.setup_test_data()

        self.open(reverse("linkding:bookmarks.archived"))

        bookmark_list = self.locate_bookmark_list().element_handle()
        self.locate_bulk_edit_toggle().click()
        self.locate_bulk_edit_select_all().click()
        self.locate_bulk_edit_select_across().click()

        self.select_bulk_action("Delete")
        self.locate_bulk_edit_bar().get_by_text("Execute").click()
        self.locate_confirm_dialog().get_by_text("Confirm").click()
        # Wait until bookmark list is updated (old reference becomes invisible)
        bookmark_list.wait_for_element_state("hidden", timeout=1000)

        self.assertEqual(
            50,
            Bookmark.objects.filter(
                is_archived=False, title__startswith="Bookmark"
            ).count(),
        )
        self.assertEqual(
            0,
            Bookmark.objects.filter(
                is_archived=True, title__startswith="Archived Bookmark"
            ).count(),
        )
        self.assertEqual(
            50,
            Bookmark.objects.filter(is_archived=False, title__startswith="foo").count(),
        )
        self.assertEqual(
            0,
            Bookmark.objects.filter(is_archived=True, title__startswith="foo").count(),
        )

    def test_active_bookmarks_bulk_select_across_respects_query(self):
        self.setup_test_data()

        self.open(reverse("linkding:bookmarks.index") + "?q=foo")

        bookmark_list = self.locate_bookmark_list().element_handle()
        self.locate_bulk_edit_toggle().click()
        self.locate_bulk_edit_select_all().click()
        self.locate_bulk_edit_select_across().click()

        self.select_bulk_action("Delete")
        self.locate_bulk_edit_bar().get_by_text("Execute").click()
        self.locate_confirm_dialog().get_by_text("Confirm").click()
        # Wait until bookmark list is updated (old reference becomes invisible)
        bookmark_list.wait_for_element_state("hidden", timeout=1000)

        self.assertEqual(
            50,
            Bookmark.objects.filter(
                is_archived=False, title__startswith="Bookmark"
            ).count(),
        )
        self.assertEqual(
            50,
            Bookmark.objects.filter(
                is_archived=True, title__startswith="Archived Bookmark"
            ).count(),
        )
        self.assertEqual(
            0,
            Bookmark.objects.filter(is_archived=False, title__startswith="foo").count(),
        )
        self.assertEqual(
            50,
            Bookmark.objects.filter(is_archived=True, title__startswith="foo").count(),
        )

    def test_archived_bookmarks_bulk_select_across_respects_query(self):
        self.setup_test_data()

        self.open(reverse("linkding:bookmarks.archived") + "?q=foo")

        bookmark_list = self.locate_bookmark_list().element_handle()
        self.locate_bulk_edit_toggle().click()
        self.locate_bulk_edit_select_all().click()
        self.locate_bulk_edit_select_across().click()

        self.select_bulk_action("Delete")
        self.locate_bulk_edit_bar().get_by_text("Execute").click()
        self.locate_confirm_dialog().get_by_text("Confirm").click()
        # Wait until bookmark list is updated (old reference becomes invisible)
        bookmark_list.wait_for_element_state("hidden", timeout=1000)

        self.assertEqual(
            50,
            Bookmark.objects.filter(
                is_archived=False, title__startswith="Bookmark"
            ).count(),
        )
        self.assertEqual(
            50,
            Bookmark.objects.filter(
                is_archived=True, title__startswith="Archived Bookmark"
            ).count(),
        )
        self.assertEqual(
            50,
            Bookmark.objects.filter(is_archived=False, title__startswith="foo").count(),
        )
        self.assertEqual(
            0,
            Bookmark.objects.filter(is_archived=True, title__startswith="foo").count(),
        )

    def test_select_all_toggles_all_checkboxes(self):
        self.setup_numbered_bookmarks(5)

        url = reverse("linkding:bookmarks.index")
        page = self.open(url)

        self.locate_bulk_edit_toggle().click()

        checkboxes = page.locator("label.bulk-edit-checkbox input")
        self.assertEqual(6, checkboxes.count())
        for i in range(checkboxes.count()):
            expect(checkboxes.nth(i)).not_to_be_checked()

        self.locate_bulk_edit_select_all().click()

        for i in range(checkboxes.count()):
            expect(checkboxes.nth(i)).to_be_checked()

        self.locate_bulk_edit_select_all().click()

        for i in range(checkboxes.count()):
            expect(checkboxes.nth(i)).not_to_be_checked()

    def test_select_all_shows_select_across(self):
        self.setup_numbered_bookmarks(5)

        url = reverse("linkding:bookmarks.index")
        self.open(url)

        self.locate_bulk_edit_toggle().click()

        expect(self.locate_bulk_edit_select_across()).not_to_be_visible()

        self.locate_bulk_edit_select_all().click()
        expect(self.locate_bulk_edit_select_across()).to_be_visible()

        self.locate_bulk_edit_select_all().click()
        expect(self.locate_bulk_edit_select_across()).not_to_be_visible()

    def test_select_across_is_unchecked_when_toggling_all(self):
        self.setup_numbered_bookmarks(5)

        url = reverse("linkding:bookmarks.index")
        self.open(url)

        self.locate_bulk_edit_toggle().click()

        # Show select across, check it
        self.locate_bulk_edit_select_all().click()
        self.locate_bulk_edit_select_across().click()
        expect(self.locate_bulk_edit_select_across()).to_be_checked()

        # Hide select across by toggling select all
        self.locate_bulk_edit_select_all().click()
        expect(self.locate_bulk_edit_select_across()).not_to_be_visible()

        # Show select across again, verify it is unchecked
        self.locate_bulk_edit_select_all().click()
        expect(self.locate_bulk_edit_select_across()).not_to_be_checked()

    def test_select_across_is_unchecked_when_toggling_bookmark(self):
        self.setup_numbered_bookmarks(5)

        url = reverse("linkding:bookmarks.index")
        self.open(url)

        self.locate_bulk_edit_toggle().click()

        # Show select across, check it
        self.locate_bulk_edit_select_all().click()
        self.locate_bulk_edit_select_across().click()
        expect(self.locate_bulk_edit_select_across()).to_be_checked()

        # Hide select across by toggling a single bookmark
        self.locate_bookmark("Bookmark 1").locator("label.bulk-edit-checkbox").click()
        expect(self.locate_bulk_edit_select_across()).not_to_be_visible()

        # Show select across again, verify it is unchecked
        self.locate_bookmark("Bookmark 1").locator("label.bulk-edit-checkbox").click()
        expect(self.locate_bulk_edit_select_across()).not_to_be_checked()

    def test_execute_resets_all_checkboxes(self):
        self.setup_numbered_bookmarks(100)

        url = reverse("linkding:bookmarks.index")
        page = self.open(url)

        bookmark_list = self.locate_bookmark_list().element_handle()

        # Select all bookmarks, enable select across
        self.locate_bulk_edit_toggle().click()
        self.locate_bulk_edit_select_all().click()
        self.locate_bulk_edit_select_across().click()

        # Execute bulk action
        self.select_bulk_action("Mark as unread")
        self.locate_bulk_edit_bar().get_by_text("Execute").click()
        self.locate_confirm_dialog().get_by_text("Confirm").click()

        # Wait until bookmark list is updated (old reference becomes invisible)
        bookmark_list.wait_for_element_state("hidden", timeout=1000)

        # Verify bulk edit checkboxes are reset
        checkboxes = page.locator("label.bulk-edit-checkbox input")
        self.assertEqual(31, checkboxes.count())
        for i in range(checkboxes.count()):
            expect(checkboxes.nth(i)).not_to_be_checked()

        # Toggle select all and verify select across is reset
        self.locate_bulk_edit_select_all().click()
        expect(self.locate_bulk_edit_select_across()).not_to_be_checked()

    def test_update_select_across_bookmark_count(self):
        self.setup_numbered_bookmarks(100)

        url = reverse("linkding:bookmarks.index")
        self.open(url)

        bookmark_list = self.locate_bookmark_list().element_handle()
        self.locate_bulk_edit_toggle().click()
        self.locate_bulk_edit_select_all().click()

        expect(
            self.locate_bulk_edit_bar().get_by_text("All 100 bookmarks")
        ).to_be_visible()

        self.select_bulk_action("Delete")
        self.locate_bulk_edit_bar().get_by_text("Execute").click()
        self.locate_confirm_dialog().get_by_text("Confirm").click()
        # Wait until bookmark list is updated (old reference becomes invisible)
        bookmark_list.wait_for_element_state("hidden", timeout=1000)

        expect(self.locate_bulk_edit_select_all()).not_to_be_checked()
        self.locate_bulk_edit_select_all().click()

        expect(
            self.locate_bulk_edit_bar().get_by_text("All 70 bookmarks")
        ).to_be_visible()

    def test_execute_button_is_disabled_when_no_bookmarks_selected(self):
        self.setup_numbered_bookmarks(5)

        url = reverse("linkding:bookmarks.index")
        self.open(url)

        self.locate_bulk_edit_toggle().click()

        execute_button = self.locate_bulk_edit_bar().get_by_text("Execute")

        # Execute button should be disabled by default
        expect(execute_button).to_be_disabled()

        # Check a single bookmark - execute button should be enabled
        self.locate_bookmark("Bookmark 1").locator("label.bulk-edit-checkbox").click()
        expect(execute_button).to_be_enabled()

        # Uncheck the bookmark - execute button should be disabled again
        self.locate_bookmark("Bookmark 1").locator("label.bulk-edit-checkbox").click()
        expect(execute_button).to_be_disabled()

        # Check all bookmarks - execute button should be enabled
        self.locate_bulk_edit_select_all().click()
        expect(execute_button).to_be_enabled()

        # Uncheck all bookmarks - execute button should be disabled again
        self.locate_bulk_edit_select_all().click()
        expect(execute_button).to_be_disabled()


================================================
FILE: bookmarks/tests_e2e/e2e_test_bookmark_page_partial_updates.py
================================================
from django.urls import reverse
from playwright.sync_api import expect

from bookmarks.tests_e2e.helpers import LinkdingE2ETestCase


class BookmarkPagePartialUpdatesE2ETestCase(LinkdingE2ETestCase):
    def setup_fixture(self):
        profile = self.get_or_create_test_user().profile
        profile.enable_sharing = True
        profile.save()

        # create a number of bookmarks with different states / visibility to
        # verify correct data is loaded on update
        self.setup_numbered_bookmarks(3, with_tags=True)
        self.setup_numbered_bookmarks(3, with_tags=True, archived=True)
        self.setup_numbered_bookmarks(
            3,
            shared=True,
            prefix="Joe's Bookmark",
            user=self.setup_user(enable_sharing=True),
        )

    def assertVisibleBookmarks(self, titles: list[str]):
        bookmark_tags = self.page.locator("ul.bookmark-list > li")
        expect(bookmark_tags).to_have_count(len(titles))

        for title in titles:
            matching_tag = bookmark_tags.filter(has_text=title)
            expect(matching_tag).to_be_visible()

    def assertVisibleTags(self, titles: list[str]):
        tag_tags = self.page.locator(".tag-cloud .unselected-tags a")
        expect(tag_tags).to_have_count(len(titles))

        for title in titles:
            matching_tag = tag_tags.filter(has_text=title)
            expect(matching_tag).to_be_visible()

    def test_partial_update_respects_query(self):
        self.setup_numbered_bookmarks(5, prefix="foo")
        self.setup_numbered_bookmarks(5, prefix="bar")

        url = reverse("linkding:bookmarks.index") + "?q=foo"
        self.open(url)

        self.assertVisibleBookmarks(["foo 1", "foo 2", "foo 3", "foo 4", "foo 5"])

        self.locate_bookmark("foo 2").get_by_text("Archive").click()
        self.assertVisibleBookmarks(["foo 1", "foo 3", "foo 4", "foo 5"])

    def test_partial_update_respects_sort(self):
        self.setup_numbered_bookmarks(5, prefix="foo")

        url = reverse("linkding:bookmarks.index") + "?sort=title_asc"
        page = self.open(url)

        first_item = page.locator("ul.bookmark-list > li").first
        expect(first_item).to_contain_text("foo 1")

        first_item.get_by_text("Archive").click()

        first_item = page.locator("ul.bookmark-list > li").first
        expect(first_item).to_contain_text("foo 2")

    def test_partial_update_respects_page(self):
        # add a suffix, otherwise 'foo 1' also matches 'foo 10'
        self.setup_numbered_bookmarks(50, prefix="foo", suffix="-")

        url = reverse("linkding:bookmarks.index") + "?q=foo&page=2"
        self.open(url)

        # with descending sort, page two has 'foo 1' to 'foo 20'
        expected_titles = [f"foo {i}-" for i in range(1, 21)]
        self.assertVisibleBookmarks(expected_titles)

        self.locate_bookmark("foo 20-").get_by_text("Archive").click()

        expected_titles = [f"foo {i}-" for i in range(1, 20)]
        self.assertVisibleBookmarks(expected_titles)

    def test_multiple_partial_updates(self):
        self.setup_numbered_bookmarks(5)

        url = reverse("linkding:bookmarks.index")
        self.open(url)

        self.locate_bookmark("Bookmark 1").get_by_text("Archive").click()
        self.assertVisibleBookmarks(
            ["Bookmark 2", "Bookmark 3", "Bookmark 4", "Bookmark 5"]
        )

        self.locate_bookmark("Bookmark 2").get_by_text("Archive").click()
        self.assertVisibleBookmarks(["Bookmark 3", "Bookmark 4", "Bookmark 5"])

        self.locate_bookmark("Bookmark 3").get_by_text("Archive").click()
        self.assertVisibleBookmarks(["Bookmark 4", "Bookmark 5"])

        self.assertReloads(0)

    def test_active_bookmarks_partial_update_on_archive(self):
        self.setup_fixture()

        self.open(reverse("linkding:bookmarks.index"))

        self.locate_bookmark("Bookmark 2").get_by_text("Archive").click()

        self.assertVisibleBookmarks(["Bookmark 1", "Bookmark 3"])
        self.assertVisibleTags(["Tag 1", "Tag 3"])
        self.assertReloads(0)

    def test_active_bookmarks_partial_update_on_delete(self):
        self.setup_fixture()

        self.open(reverse("linkding:bookmarks.index"))

        self.locate_bookmark("Bookmark 2").get_by_text("Remove").click()
        self.locate_confirm_dialog().get_by_text("Confirm").click()

        self.assertVisibleBookmarks(["Bookmark 1", "Bookmark 3"])
        self.assertVisibleTags(["Tag 1", "Tag 3"])
        self.assertReloads(0)

    def test_active_bookmarks_partial_update_on_mark_as_read(self):
        self.setup_fixture()
        bookmark2 = self.get_numbered_bookmark("Bookmark 2")
        bookmark2.unread = True
        bookmark2.save()

        self.open(reverse("linkding:bookmarks.index"))

        expect(self.locate_bookmark("Bookmark 2")).to_have_class("unread")
        self.locate_bookmark("Bookmark 2").get_by_text("Unread").click()
        self.locate_confirm_dialog().get_by_text("Confirm").click()

        expect(self.locate_bookmark("Bookmark 2")).not_to_have_class("unread")
        self.assertReloads(0)

    def test_active_bookmarks_partial_update_on_unshare(self):
        self.setup_fixture()
        bookmark2 = self.get_numbered_bookmark("Bookmark 2")
        bookmark2.shared = True
        bookmark2.save()

        self.open(reverse("linkding:bookmarks.index"))

        expect(self.locate_bookmark("Bookmark 2")).to_have_class("shared")
        self.locate_bookmark("Bookmark 2").get_by_text("Shared").click()
        self.locate_confirm_dialog().get_by_text("Confirm").click()

        expect(self.locate_bookmark("Bookmark 2")).not_to_have_class("shared")
        self.assertReloads(0)

    def test_active_bookmarks_partial_update_on_bulk_archive(self):
        self.setup_fixture()

        self.open(reverse("linkding:bookmarks.index"))

        self.locate_bulk_edit_toggle().click()
        self.locate_bookmark("Bookmark 2").locator("label.bulk-edit-checkbox").click()
        self.select_bulk_action("Archive")
        self.locate_bulk_edit_bar().get_by_text("Execute").click()
        self.locate_confirm_dialog().get_by_text("Confirm").click()

        self.assertVisibleBookmarks(["Bookmark 1", "Bookmark 3"])
        self.assertVisibleTags(["Tag 1", "Tag 3"])
        self.assertReloads(0)

    def test_active_bookmarks_partial_update_on_bulk_delete(self):
        self.setup_fixture()

        self.open(reverse("linkding:bookmarks.index"))

        self.locate_bulk_edit_toggle().click()
        self.locate_bookmark("Bookmark 2").locator("label.bulk-edit-checkbox").click()
        self.select_bulk_action("Delete")
        self.locate_bulk_edit_bar().get_by_text("Execute").click()
        self.locate_confirm_dialog().get_by_text("Confirm").click()

        self.assertVisibleBookmarks(["Bookmark 1", "Bookmark 3"])
        self.assertVisibleTags(["Tag 1", "Tag 3"])
        self.assertReloads(0)

    def test_archived_bookmarks_partial_update_on_unarchive(self):
        self.setup_fixture()

        self.open(reverse("linkding:bookmarks.archived"))

        self.locate_bookmark("Archived Bookmark 2").get_by_text("Unarchive").click()

        self.assertVisibleBookmarks(["Archived Bookmark 1", "Archived Bookmark 3"])
        self.assertVisibleTags(["Archived Tag 1", "Archived Tag 3"])
        self.assertReloads(0)

    def test_archived_bookmarks_partial_update_on_delete(self):
        self.setup_fixture()

        self.open(reverse("linkding:bookmarks.archived"))

        self.locate_bookmark("Archived Bookmark 2").get_by_text("Remove").click()
        self.locate_confirm_dialog().get_by_text("Confirm").click()

        self.assertVisibleBookmarks(["Archived Bookmark 1", "Archived Bookmark 3"])
        self.assertVisibleTags(["Archived Tag 1", "Archived Tag 3"])
        self.assertReloads(0)

    def test_archived_bookmarks_partial_update_on_bulk_unarchive(self):
        self.setup_fixture()

        self.open(reverse("linkding:bookmarks.archived"))

        self.locate_bulk_edit_toggle().click()
        self.locate_bookmark("Archived Bookmark 2").locator(
            "label.bulk-edit-checkbox"
        ).click()
        self.select_bulk_action("Unarchive")
        self.locate_bulk_edit_bar().get_by_text("Execute").click()
        self.locate_confirm_dialog().get_by_text("Confirm").click()

        self.assertVisibleBookmarks(["Archived Bookmark 1", "Archived Bookmark 3"])
        self.assertVisibleTags(["Archived Tag 1", "Archived Tag 3"])
        self.assertReloads(0)

    def test_archived_bookmarks_partial_update_on_bulk_delete(self):
        self.setup_fixture()

        self.open(reverse("linkding:bookmarks.archived"))

        self.locate_bulk_edit_toggle().click()
        self.locate_bookmark("Archived Bookmark 2").locator(
            "label.bulk-edit-checkbox"
        ).click()
        self.select_bulk_action("Delete")
        self.locate_bulk_edit_bar().get_by_text("Execute").click()
        self.locate_confirm_dialog().get_by_text("Confirm").click()

        self.assertVisibleBookmarks(["Archived Bookmark 1", "Archived Bookmark 3"])
        self.assertVisibleTags(["Archived Tag 1", "Archived Tag 3"])
        self.assertReloads(0)

    def test_shared_bookmarks_partial_update_on_unarchive(self):
        self.setup_fixture()
        self.setup_numbered_bookmarks(
            3, shared=True, prefix="My Bookmark", with_tags=True
        )

        self.open(reverse("linkding:bookmarks.shared"))

        self.locate_bookmark("My Bookmark 2").get_by_text("Archive").click()

        # Shared bookmarks page also shows archived bookmarks, though it probably shouldn't
        self.assertVisibleBookmarks(
            [
                "My Bookmark 1",
                "My Bookmark 2",
                "My Bookmark 3",
                "Joe's Bookmark 1",
                "Joe's Bookmark 2",
                "Joe's Bookmark 3",
            ]
        )
        self.assertVisibleTags(["Shared Tag 1", "Shared Tag 2", "Shared Tag 3"])
        self.assertReloads(0)

    def test_shared_bookmarks_partial_update_on_delete(self):
        self.setup_fixture()
        self.setup_numbered_bookmarks(
            3, shared=True, prefix="My Bookmark", with_tags=True
        )

        self.open(reverse("linkding:bookmarks.shared"))

        self.locate_bookmark("My Bookmark 2").get_by_text("Remove").click()
        self.locate_confirm_dialog().get_by_text("Confirm").click()

        self.assertVisibleBookmarks(
            [
                "My Bookmark 1",
                "My Bookmark 3",
                "Joe's Bookmark 1",
                "Joe's Bookmark 2",
                "Joe's Bookmark 3",
            ]
        )
        self.assertVisibleTags(["Shared Tag 1", "Shared Tag 3"])
        self.assertReloads(0)


================================================
FILE: bookmarks/tests_e2e/e2e_test_bundle_preview.py
================================================
from django.urls import reverse
from playwright.sync_api import expect

from bookmarks.tests_e2e.helpers import LinkdingE2ETestCase


class BookmarkItemE2ETestCase(LinkdingE2ETestCase):
    def test_update_preview_on_filter_changes(self):
        group1 = self.setup_numbered_bookmarks(3, prefix="foo")
        group2 = self.setup_numbered_bookmarks(3, prefix="bar")

        # shows all bookmarks initially
        page = self.open(reverse("linkding:bundles.new"))

        expect(
            page.get_by_text("Found 6 bookmarks matching this bundle")
        ).to_be_visible()
        self.assertVisibleBookmarks(group1 + group2)

        # filter by group1
        search = page.get_by_label("Search")
        search.fill("foo")

        expect(
            page.get_by_text("Found 3 bookmarks matching this bundle")
        ).to_be_visible()
        self.assertVisibleBookmarks(group1)

        # filter by group2
        search.fill("bar")

        expect(
            page.get_by_text("Found 3 bookmarks matching this bundle")
        ).to_be_visible()
        self.assertVisibleBookmarks(group2)

        # filter by invalid group
        search.fill("invalid")

        expect(
            page.get_by_text("No bookmarks match the current bundle")
        ).to_be_visible()
        self.assertVisibleBookmarks([])

    def assertVisibleBookmarks(self, bookmarks):
        self.assertEqual(len(bookmarks), self.count_bookmarks())

        for bookmark in bookmarks:
            expect(self.locate_bookmark(bookmark.title)).to_be_visible()


================================================
FILE: bookmarks/tests_e2e/e2e_test_collapse_side_panel.py
================================================
from django.urls import reverse
from playwright.sync_api import expect

from bookmarks.tests_e2e.helpers import LinkdingE2ETestCase


class CollapseSidePanelE2ETestCase(LinkdingE2ETestCase):
    def setUp(self) -> None:
        super().setUp()

    def assertSidePanelIsVisible(self):
        expect(self.page.locator(".bookmarks-page .side-panel")).to_be_visible()
        expect(
            self.page.locator(".bookmarks-page ld-filter-drawer-trigger")
        ).not_to_be_visible()

    def assertSidePanelIsHidden(self):
        expect(self.page.locator(".bookmarks-page .side-panel")).not_to_be_visible()
        expect(
            self.page.locator(".bookmarks-page ld-filter-drawer-trigger")
        ).to_be_visible()

    def test_side_panel_should_be_visible_by_default(self):
        self.open(reverse("linkding:bookmarks.index"))
        self.assertSidePanelIsVisible()

        self.page.goto(self.live_server_url + reverse("linkding:bookmarks.archived"))
        self.assertSidePanelIsVisible()

        self.page.goto(self.live_server_url + reverse("linkding:bookmarks.shared"))
        self.assertSidePanelIsVisible()

    def test_side_panel_should_be_hidden_when_collapsed(self):
        user = self.get_or_create_test_user()
        user.profile.collapse_side_panel = True
        user.profile.save()

        self.open(reverse("linkding:bookmarks.index"))
        self.assertSidePanelIsHidden()

        self.page.goto(self.live_server_url + reverse("linkding:bookmarks.archived"))
        self.assertSidePanelIsHidden()

        self.page.goto(self.live_server_url + reverse("linkding:bookmarks.shared"))
        self.assertSidePanelIsHidden()


================================================
FILE: bookmarks/tests_e2e/e2e_test_dropdown.py
================================================
from django.urls import reverse
from playwright.sync_api import expect

from bookmarks.tests_e2e.helpers import LinkdingE2ETestCase


class DropdownE2ETestCase(LinkdingE2ETestCase):
    def locate_dropdown(self):
        # Use bookmarks dropdown as an example instance to test
        return self.page.locator("ld-dropdown").filter(
            has=self.page.get_by_role("button", name="Bookmarks")
        )

    def locate_dropdown_toggle(self):
        return self.locate_dropdown().locator(".dropdown-toggle")

    def locate_dropdown_menu(self):
        return self.locate_dropdown().locator(".menu")

    def test_click_toggle_opens_and_closes_dropdown(self):
        self.open(reverse("linkding:bookmarks.index"))

        toggle = self.locate_dropdown_toggle()
        menu = self.locate_dropdown_menu()

        # Open dropdown
        toggle.click()
        expect(menu).to_be_visible()

        # Click toggle again to close
        toggle.click()
        expect(menu).not_to_be_visible()

    def test_outside_click_closes_dropdown(self):
        self.open(reverse("linkding:bookmarks.index"))

        toggle = self.locate_dropdown_toggle()
        menu = self.locate_dropdown_menu()

        # Open dropdown
        toggle.click()
        expect(menu).to_be_visible()

        # Click outside the dropdown (on the page body)
        self.page.locator("main").click()
        expect(menu).not_to_be_visible()

    def test_escape_closes_dropdown_and_restores_focus(self):
        self.open(reverse("linkding:bookmarks.index"))

        toggle = self.locate_dropdown_toggle()
        menu = self.locate_dropdown_menu()

        # Open dropdown
        toggle.click()
        expect(menu).to_be_visible()

        # Press Escape
        self.page.keyboard.press("Escape")

        # Menu should be closed
        expect(menu).not_to_be_visible()

        # Focus should be back on toggle
        expect(toggle).to_be_focused()

    def test_focus_out_closes_dropdown(self):
        self.open(reverse("linkding:bookmarks.index"))

        toggle = self.locate_dropdown_toggle()
        menu = self.locate_dropdown_menu()

        # Open dropdown
        toggle.click()
        expect(menu).to_be_visible()

        # Shift+Tab to move focus out of the dropdown
        self.page.keyboard.press("Shift+Tab")

        # Menu should be closed after focus leaves
        expect(menu).not_to_be_visible()

    def test_aria_expanded_attribute(self):
        self.open(reverse("linkding:bookmarks.index"))

        toggle = self.locate_dropdown_toggle()
        menu = self.locate_dropdown_menu()

        # Initially aria-expanded should be false
        expect(toggle).to_have_attribute("aria-expanded", "false")

        # Open dropdown
        toggle.click()
        expect(menu).to_be_visible()

        # aria-expanded should be true
        expect(toggle).to_have_attribute("aria-expanded", "true")

        # Close dropdown
        toggle.click()
        expect(menu).not_to_be_visible()

        # aria-expanded should be false again
        expect(toggle).to_have_attribute("aria-expanded", "false")

    def test_can_click_menu_item(self):
        self.open(reverse("linkding:bookmarks.index"))

        toggle = self.locate_dropdown_toggle()
        menu = self.locate_dropdown_menu()

        # Open dropdown
        toggle.click()
        expect(menu).to_be_visible()

        # Click on "Archived" menu item
        menu.get_by_text("Archived", exact=True).click()

        # Should navigate to archived page
        expect(self.page).to_have_url(
            self.live_server_url + reverse("linkding:bookmarks.archived")
        )


================================================
FILE: bookmarks/tests_e2e/e2e_test_edit_bookmark_form.py
================================================
from unittest.mock import patch

from django.urls import reverse
from playwright.sync_api import expect

from bookmarks.services import website_loader
from bookmarks.tests_e2e.helpers import LinkdingE2ETestCase

mock_website_metadata = website_loader.WebsiteMetadata(
    url="https://example.com",
    title="Example Domain",
    description="This domain is for use in illustrative examples in documents. You may use this domain in literature without prior coordination or asking for permission.",
    preview_image=None,
)


class BookmarkFormE2ETestCase(LinkdingE2ETestCase):
    def setUp(self) -> None:
        super().setUp()
        self.website_loader_patch = patch.object(
            website_loader, "load_website_metadata", return_value=mock_website_metadata
        )
        self.website_loader_patch.start()

    def tearDown(self) -> None:
        self.website_loader_patch.stop()
        super().tearDown()

    def test_should_not_check_for_existing_bookmark(self):
        bookmark = self.setup_bookmark()

        page = self.open(reverse("linkding: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_should_not_prefill_title_and_description(self):
        bookmark = self.setup_bookmark(
            title="Initial title", description="Initial description"
        )

        page = self.open(reverse("linkding:bookmarks.edit", args=[bookmark.id]))
        page.wait_for_timeout(timeout=1000)

        title = page.get_by_label("Title")
        description = page.get_by_label("Description")
        expect(title).to_have_value(bookmark.title)
        expect(description).to_have_value(bookmark.description)

    def test_enter_url_should_not_prefill_title_and_description(self):
        bookmark = self.setup_bookmark()

        page = self.open(reverse("linkding:bookmarks.edit", args=[bookmark.id]))

        page.get_by_label("URL").fill("https://example.com")
        page.wait_for_timeout(timeout=1000)

        title = page.get_by_label("Title")
        description = page.get_by_label("Description")
        expect(title).to_have_value(bookmark.title)
        expect(description).to_have_value(bookmark.description)

    def test_refresh_button_should_be_visible_when_editing(self):
        bookmark = self.setup_bookmark()

        page = self.open(reverse("linkding:bookmarks.edit", args=[bookmark.id]))

        refresh_button = page.get_by_text("Refresh from website")
        expect(refresh_button).to_be_visible()


================================================
FILE: bookmarks/tests_e2e/e2e_test_filter_drawer.py
================================================
from django.urls import reverse
from playwright.sync_api import expect

from bookmarks.tests_e2e.helpers import LinkdingE2ETestCase


class FilterDrawerE2ETestCase(LinkdingE2ETestCase):
    def test_show_modal_close_modal(self):
        self.setup_bookmark(tags=[self.setup_tag(name="cooking")])
        self.setup_bookmark(tags=[self.setup_tag(name="hiking")])

        page = self.open(reverse("linkding:bookmarks.index"))

        # use smaller viewport to make filter button visible
        page.set_viewport_size({"width": 375, "height": 812})

        # open drawer
        drawer_trigger = page.locator(".main").get_by_role("button", name="Filters")
        drawer_trigger.click()

        # verify drawer is visible
        drawer = page.locator("ld-filter-drawer")
        expect(drawer).to_be_visible()
        expect(drawer.locator("h2")).to_have_text("Filters")

        # close with close button
        drawer.locator("button.close").click()
        expect(drawer).to_be_hidden()

        # open drawer again
        drawer_trigger.click()

        # close with backdrop
        backdrop = drawer.locator(".modal-overlay")
        backdrop.click(position={"x": 0, "y": 0})
        expect(drawer).to_be_hidden()

    def test_select_tag(self):
        self.setup_bookmark(tags=[self.setup_tag(name="cooking")])
        self.setup_bookmark(tags=[self.setup_tag(name="hiking")])

        page = self.open(reverse("linkding:bookmarks.index"))

        # use smaller viewport to make filter button visible
        page.set_viewport_size({"width": 375, "height": 812})

        # open tag cloud modal
        drawer_trigger = page.locator(".main").get_by_role("button", name="Filters")
        drawer_trigger.click()

        # verify tags are displayed
        drawer = page.locator("ld-filter-drawer")
        unselected_tags = drawer.locator(".unselected-tags")
        expect(unselected_tags.get_by_text("cooking")).to_be_visible()
        expect(unselected_tags.get_by_text("hiking")).to_be_visible()

        # select tag
        unselected_tags.get_by_text("cooking").click()

        # open drawer again
        drawer_trigger.click()

        # verify tag is selected, other tag is not visible anymore
        selected_tags = drawer.locator(".selected-tags")
        expect(selected_tags.get_by_text("cooking")).to_be_visible()

        expect(unselected_tags.get_by_text("cooking")).not_to_be_visible()
        expect(unselected_tags.get_by_text("hiking")).not_to_be_visible()


================================================
FILE: bookmarks/tests_e2e/e2e_test_global_shortcuts.py
================================================
from django.urls import reverse
from playwright.sync_api import expect

from bookmarks.tests_e2e.helpers import LinkdingE2ETestCase


class GlobalShortcutsE2ETestCase(LinkdingE2ETestCase):
    def test_focus_search(self):
        self.open(reverse("linkding:bookmarks.index"))

        self.page.press("body", "s")

        expect(
            self.page.get_by_placeholder("Search for words or #tags")
        ).to_be_focused()

    def test_add_bookmark(self):
        self.open(reverse("linkding:bookmarks.index"))

        self.page.press("body", "n")

        expect(self.page).to_have_url(
            self.live_server_url + reverse("linkding:bookmarks.new")
        )


================================================
FILE: bookmarks/tests_e2e/e2e_test_new_bookmark_form.py
================================================
from unittest.mock import patch
from urllib.parse import quote

from django.urls import reverse
from playwright.sync_api import expect

from bookmarks.models import Bookmark
from bookmarks.services import website_loader
from bookmarks.tests_e2e.helpers import LinkdingE2ETestCase

mock_website_metadata = website_loader.WebsiteMetadata(
    url="https://example.com",
    title="Example Domain",
    description="This domain is for use in illustrative examples in documents. You may use this domain in literature without prior coordination or asking for permission.",
    preview_image=None,
)


class BookmarkFormE2ETestCase(LinkdingE2ETestCase):
    def setUp(self) -> None:
        super().setUp()
        self.website_loader_patch = patch.object(
            website_loader, "load_website_metadata", return_value=mock_website_metadata
        )
        self.website_loader_mock = self.website_loader_patch.start()

    def tearDown(self) -> None:
        self.website_loader_patch.stop()
        super().tearDown()

    def test_enter_url_prefills_title_and_description(self):
        page = self.open(reverse("linkding:bookmarks.new"))
        url = page.get_by_label("URL")
        title = page.get_by_label("Title")
        description = page.get_by_label("Description")

        url.fill("https://example.com")
        expect(title).to_have_value("Example Domain")
        expect(description).to_have_value(
            "This domain is for use in illustrative examples in documents. You may use this domain in literature without prior coordination or asking for permission."
        )

    def test_enter_url_does_not_overwrite_modified_title_and_description(self):
        page = self.open(reverse("linkding:bookmarks.new"))
        url = page.get_by_label("URL")
        title = page.get_by_label("Title")
        description = page.get_by_label("Description")

        title.fill("Modified title")
        description.fill("Modified description")
        url.fill("https://example.com")
        page.wait_for_timeout(timeout=1000)

        expect(title).to_have_value("Modified title")
        expect(description).to_have_value("Modified description")

    def test_with_initial_url_prefills_title_and_description(self):
        page_url = (
            reverse("linkding:bookmarks.new") + f"?url={quote('https://example.com')}"
        )
        page = self.open(page_url)
        url = page.get_by_label("URL")
        title = page.get_by_label("Title")
        description = page.get_by_label("Description")

        page.wait_for_timeout(timeout=1000)

        expect(url).to_have_value("https://example.com")
        expect(title).to_have_value("Example Domain")
        expect(description).to_have_value(
            "This domain is for use in illustrative examples in documents. You may use this domain in literature without prior coordination or asking for permission."
        )

    def test_with_initial_url_title_description_does_not_overwrite_title_and_description(
        self,
    ):
        page_url = (
            reverse("linkding:bookmarks.new")
            + f"?url={quote('https://example.com')}&title=Initial+title&description=Initial+description"
        )
        page = self.open(page_url)
        url = page.get_by_label("URL")
        title = page.get_by_label("Title")
        description = page.get_by_label("Description")

        page.wait_for_timeout(timeout=1000)

        expect(url).to_have_value("https://example.com")
        expect(title).to_have_value("Initial title")
        expect(description).to_have_value("Initial description")

    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")],
            unread=True,
        )
        tag_names = " ".join(existing_bookmark.tag_names)

        page = self.open(reverse("linkding: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(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
        )

    def test_enter_url_of_existing_bookmark_should_show_notes(self):
        bookmark = self.setup_bookmark(
            notes="Existing notes", description="Existing description"
        )

        page = self.open(reverse("linkding: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="")

    def test_create_should_preview_auto_tags(self):
        profile = self.get_or_create_test_user().profile
        profile.auto_tagging_rules = "github.com dev github"
        profile.save()

        # Open page with URL that should have auto tags
        url = (
            reverse("linkding:bookmarks.new")
            + "?url=https%3A%2F%2Fgithub.com%2Fsissbruecker%2Flinkding"
        )
        page = self.open(url)

        auto_tags_hint = page.locator(".form-input-hint.auto-tags")
        expect(auto_tags_hint).to_be_visible()
        expect(auto_tags_hint).to_have_text("Auto tags: dev github")

        # Change to URL without auto tags
        page.get_by_label("URL").fill("https://example.com")

        expect(auto_tags_hint).to_be_hidden()

    def test_clear_buttons_only_shown_when_fields_have_content(self):
        page = self.open(reverse("linkding:bookmarks.new"))

        title_field = page.get_by_label("Title")
        title_clear_button = page.locator("ld-clear-button[data-for='id_title']")
        description_field = page.get_by_label("Description")
        description_clear_button = page.locator(
            "ld-clear-button[data-for='id_description']"
        )

        # Initially, clear buttons should be hidden because fields are empty
        expect(title_clear_button).to_be_hidden()
        expect(description_clear_button).to_be_hidden()

        # Add content to title field, its clear button should become visible
        title_field.fill("Test title")
        expect(title_clear_button).to_be_visible()

        # Add content to description field, its clear button should become visible
        description_field.fill("Test description")
        expect(description_clear_button).to_be_visible()

        # Clear title field, its clear button should be hidden again
        title_field.fill("")
        expect(title_clear_button).to_be_hidden()

        # Clear description field, its clear button should be hidden again
        description_field.fill("")
        expect(description_clear_button).to_be_hidden()

    def test_refresh_button_only_shown_for_existing_bookmarks(self):
        existing_bookmark = self.setup_bookmark(
            title="Existing title", description="Existing description"
        )

        page = self.open(reverse("linkding:bookmarks.new"))
        refresh_button = page.locator("#refresh-button")

        # Initially, refresh button should be hidden
        expect(refresh_button).to_be_hidden()

        # Enter a URL that is not bookmarked yet
        page.get_by_label("URL").fill("https://example.com/not-bookmarked")
        page.wait_for_timeout(timeout=1000)

        expect(refresh_button).to_be_hidden()

        # Enter a URL that is already bookmarked
        page.get_by_label("URL").fill(existing_bookmark.url)

        expect(refresh_button).to_be_visible()

        # Change back to non-bookmarked URL
        page.get_by_label("URL").fill("https://example.com/another-not-bookmarked")

        expect(refresh_button).to_be_hidden()

    def test_refresh_from_website_button_updates_title_and_description(self):
        existing_bookmark = self.setup_bookmark(
            title="Existing title", description="Existing description"
        )

        page = self.open(reverse("linkding:bookmarks.new"))
        url_field = page.get_by_label("URL")
        title_field = page.get_by_label("Title")
        description_field = page.get_by_label("Description")
        refresh_button = page.locator("#refresh-button")

        # Enter the URL of the existing bookmark to make refresh button visible
        url_field.fill(existing_bookmark.url)

        # Wait for metadata to be loaded and for refresh button to be visible
        expect(refresh_button).to_be_visible()
        expect(title_field).to_have_value("Existing title")
        expect(description_field).to_have_value("Existing description")

        # Update the mock to return different metadata when refresh is requested
        self.website_loader_mock.reset_mock()
        self.website_loader_mock.return_value = website_loader.WebsiteMetadata(
            url="https://example.com",
            title="Updated Example Domain",
            description="This is a refreshed description for the example domain.",
            preview_image=None,
        )

        # Click the refresh button
        refresh_button.click()

        # Verify that title and description have been updated with new values
        expect(title_field).to_have_value("Updated Example Domain")
        expect(description_field).to_have_value(
            "This is a refreshed description for the example domain."
        )

        # Verify that the fields are visually marked as modified
        expect(title_field).to_have_class("form-input modified")
        expect(description_field).to_have_class("form-input modified")

    def test_refresh_from_website_button_does_not_modify_fields_if_metadata_is_same(
        self,
    ):
        existing_bookmark = self.setup_bookmark(
            title="Existing title", description="Existing description"
        )

        page = self.open(reverse("linkding:bookmarks.new"))
        url_field = page.get_by_label("URL")
        title_field = page.get_by_label("Title")
        description_field = page.get_by_label("Description")
        refresh_button = page.locator("#refresh-button")

        # Enter the URL of the existing bookmark to make refresh button visible
        url_field.fill(existing_bookmark.url)

        # Wait for metadata to be loaded and for refresh button to be visible
        expect(refresh_button).to_be_visible()
        expect(title_field).to_have_value("Existing title")
        expect(description_field).to_have_value("Existing description")

        # Update the mock to return same metadata when refresh is requested
        self.website_loader_mock.reset_mock()
        self.website_loader_mock.return_value = website_loader.WebsiteMetadata(
            url="https://example.com",
            title="Existing title",
            description="Existing description",
            preview_image=None,
        )

        # Click the refresh button
        refresh_button.click()
        page.wait_for_timeout(timeout=1000)

        # Verify that title and description values are still the same
        expect(title_field).to_have_value("Existing title")
        expect(description_field).to_have_value("Existing description")

        # Verify that the fields are NOT visually marked as modified
        expect(title_field).to_have_class("form-input")
        expect(description_field).to_have_class("form-input")

    def test_ctrl_enter_submits_form_from_description(self):
        page = self.open(reverse("linkding:bookmarks.new"))
        url_field = page.get_by_label("URL")
        description_field = page.get_by_label("Description")

        url_field.fill("https://example.com")
        description_field.fill("Test description")
        description_field.focus()

        # Press Ctrl+Enter to submit form
        description_field.press("Control+Enter")

        # Should navigate away from new bookmark page after successful submission
        expect(page).not_to_have_url(
            self.live_server_url + reverse("linkding:bookmarks.new")
        )

        self.assertEqual(1, Bookmark.objects.count())
        bookmark = Bookmark.objects.first()
        self.assertEqual("https://example.com", bookmark.url)
        self.assertEqual("Test description", bookmark.description)


================================================
FILE: bookmarks/tests_e2e/e2e_test_settings_general.py
================================================
from django.urls import reverse
from playwright.sync_api import expect

from bookmarks.models import UserProfile
from bookmarks.tests_e2e.helpers import LinkdingE2ETestCase


class SettingsGeneralE2ETestCase(LinkdingE2ETestCase):
    def test_should_only_enable_public_sharing_if_sharing_is_enabled(self):
        self.open(reverse("linkding:settings.general"))

        enable_sharing = self.page.get_by_label("Enable bookmark sharing")
        enable_sharing_label = self.page.get_by_text("Enable bookmark sharing")
        enable_public_sharing = self.page.get_by_label("Enable public bookmark sharing")
        enable_public_sharing_label = self.page.get_by_text(
            "Enable public bookmark sharing"
        )
        default_mark_shared = self.page.get_by_label(
            "Create bookmarks as shared by default"
        )
        default_mark_shared_label = self.page.get_by_text(
            "Create bookmarks as shared by default"
        )

        # Public sharing and default shared are disabled by default
        expect(enable_sharing).not_to_be_checked()
        expect(enable_public_sharing).not_to_be_checked()
        expect(enable_public_sharing).to_be_disabled()
        expect(default_mark_shared).not_to_be_checked()
        expect(default_mark_shared).to_be_disabled()

        # Enable sharing
        enable_sharing_label.click()
        expect(enable_sharing).to_be_checked()
        expect(enable_public_sharing).not_to_be_checked()
        expect(enable_public_sharing).to_be_enabled()
        expect(default_mark_shared).not_to_be_checked()
        expect(default_mark_shared).to_be_enabled()

        # Enable public sharing and default shared
        enable_public_sharing_label.click()
        default_mark_shared_label.click()
        expect(enable_public_sharing).to_be_checked()
        expect(enable_public_sharing).to_be_enabled()
        expect(default_mark_shared).to_be_checked()
        expect(default_mark_shared).to_be_enabled()

        # Disable sharing
        enable_sharing_label.click()
        expect(enable_sharing).not_to_be_checked()
        expect(enable_public_sharing).not_to_be_checked()
        expect(enable_public_sharing).to_be_disabled()
        expect(default_mark_shared).not_to_be_checked()
        expect(default_mark_shared).to_be_disabled()

    def test_should_not_show_bookmark_description_max_lines_when_display_inline(self):
        profile = self.get_or_create_test_user().profile
        profile.bookmark_description_display = (
            UserProfile.BOOKMARK_DESCRIPTION_DISPLAY_INLINE
        )
        profile.save()

        self.open(reverse("linkding:settings.general"))

        max_lines = self.page.get_by_label("Bookmark description max lines")
        expect(max_lines).to_be_hidden()

    def test_should_show_bookmark_description_max_lines_when_display_separate(self):
        profile = self.get_or_create_test_user().profile
        profile.bookmark_description_display = (
            UserProfile.BOOKMARK_DESCRIPTION_DISPLAY_SEPARATE
        )
        profile.save()

        self.open(reverse("linkding:settings.general"))

        max_lines = self.page.get_by_label("Bookmark description max lines")
        expect(max_lines).to_be_visible()

    def test_should_update_bookmark_description_max_lines_when_changing_display(self):
        self.open(reverse("linkding:settings.general"))

        max_lines = self.page.get_by_label("Bookmark description max lines")
        expect(max_lines).to_be_hidden()

        display = self.page.get_by_label("Bookmark description", exact=True)
        display.select_option("separate")
        expect(max_lines).to_be_visible()

        display.select_option("inline")
        expect(max_lines).to_be_hidden()


================================================
FILE: bookmarks/tests_e2e/e2e_test_settings_integrations.py
================================================
from django.urls import reverse
from playwright.sync_api import expect

from bookmarks.tests_e2e.helpers import LinkdingE2ETestCase


class SettingsIntegrationsE2ETestCase(LinkdingE2ETestCase):
    def test_create_api_token(self):
        self.open(reverse("linkding:settings.integrations"))

        # Click create API token button
        self.page.get_by_text("Create API token").click()

        # Wait for modal to appear
        modal = self.page.locator(".modal")
        expect(modal).to_be_visible()

        # Enter custom token name
        token_name_input = modal.locator("#token-name")
        token_name_input.fill("")
        token_name_input.fill("My Test Token")

        # Confirm the dialog
        modal.page.get_by_role("button", name="Create Token").click()

        # Verify the API token key is shown in the input
        new_token_input = self.page.locator("#new-token-key")
        expect(new_token_input).to_be_visible()
        token_value = new_token_input.input_value()
        self.assertTrue(len(token_value) > 0)

        # Verify the API token is now listed in the table
        token_table = self.page.locator("table.crud-table")
        expect(token_table).to_be_visible()
        expect(token_table.get_by_text("My Test Token")).to_be_visible()

        # Verify the dialog is gone
        expect(modal).to_be_hidden()

        # Reload the page to verify the API token key is only shown once
        self.page.reload()

        # Token key input should no longer be visible
        expect(new_token_input).not_to_be_visible()

        # But the token should still be listed in the table
        expect(token_table.get_by_text("My Test Token")).to_be_visible()

    def test_delete_api_token(self):
        self.setup_api_token(name="Token To Delete")

        self.open(reverse("linkding:settings.integrations"))

        token_table = self.page.locator("table.crud-table")
        expect(token_table.get_by_text("Token To Delete")).to_be_visible()

        # Click delete button for the token
        token_row = token_table.locator("tr").filter(has_text="Token To Delete")
        token_row.get_by_role("button", name="Delete").click()

        # Confirm deletion
        self.locate_confirm_dialog().get_by_text("Confirm").click()

        # Verify the token is removed from the table
        expect(token_table.get_by_text("Token To Delete")).not_to_be_visible()


================================================
FILE: bookmarks/tests_e2e/e2e_test_tag_management.py
================================================
from django.urls import reverse
from playwright.sync_api import expect

from bookmarks.models import Tag
from bookmarks.tests_e2e.helpers import LinkdingE2ETestCase


class TagManagementE2ETestCase(LinkdingE2ETestCase):
    def locate_tag_modal(self):
        modal = self.page.locator("ld-modal.tag-edit-modal")
        expect(modal).to_be_visible()
        return modal

    def locate_merge_modal(self):
        modal = self.page.locator("ld-modal").filter(has_text="Merge Tags")
        expect(modal).to_be_visible()
        return modal

    def locate_tag_row(self, name: str):
        return self.page.locator("table.crud-table tbody tr").filter(has_text=name)

    def verify_success_message(self, text: str):
        success_message = self.page.locator(".toast.toast-success")
        expect(success_message).to_be_visible()
        expect(success_message).to_contain_text(text)

    def test_create_tag(self):
        self.open(reverse("linkding:tags.index"))

        # Click the Create Tag button to open the modal
        self.page.get_by_text("Create Tag").click()

        modal = self.locate_tag_modal()

        # Fill in a tag name
        name_input = modal.get_by_label("Name")
        name_input.fill("test-tag")

        # Submit the form
        modal.get_by_text("Save").click()

        # Verify modal is closed and we're back on the tags page
        expect(modal).not_to_be_visible()

        # Verify the success message is shown
        self.verify_success_message('Tag "test-tag" created successfully.')

        # Verify the new tag is shown in the list
        tag_row = self.locate_tag_row("test-tag")
        expect(tag_row).to_be_visible()

        # Verify the tag was actually created in the database
        self.assertEqual(
            Tag.objects.filter(owner=self.get_or_create_test_user()).count(), 1
        )
        tag = Tag.objects.get(owner=self.get_or_create_test_user())
        self.assertEqual(tag.name, "test-tag")

    def test_create_tag_validation_error(self):
        existing_tag = self.setup_tag(name="existing-tag")

        self.open(reverse("linkding:tags.index"))

        # Click the Create Tag button to open the modal
        self.page.get_by_text("Create Tag").click()

        modal = self.locate_tag_modal()

        # Submit with empty value
        modal.get_by_text("Save").click()

        # Verify the error is shown (field is required)
        error_hint = modal.get_by_text("This field is required")
        expect(error_hint).to_be_visible()

        # Fill in the name of an existing tag
        name_input = modal.get_by_label("Name")
        name_input.fill(existing_tag.name)

        # Submit the form
        modal.get_by_text("Save").click()

        # Verify the error is shown (tag already exists)
        error_hint = modal.get_by_text('Tag "existing-tag" already exists')
        expect(error_hint).to_be_visible()

        # Verify no additional tag was created
        self.assertEqual(
            Tag.objects.filter(owner=self.get_or_create_test_user()).count(), 1
        )

    def test_edit_tag(self):
        tag = self.setup_tag(name="old-name")

        self.open(reverse("linkding:tags.index"))

        # Click the Edit button for the tag
        tag_row = self.locate_tag_row(tag.name)
        tag_row.get_by_role("link", name="Edit").click()

        modal = self.locate_tag_modal()

        # Verify the form is pre-filled with the tag name
        name_input = modal.get_by_label("Name")
        expect(name_input).to_have_value(tag.name)

        # Change the tag name
        name_input.fill("new-name")

        # Submit the form
        modal.get_by_text("Save").click()

        # Verify modal is closed
        expect(modal).not_to_be_visible()

        # Verify the updated tag is shown in the list
        expect(self.locate_tag_row("new-name")).to_be_visible()
        expect(self.locate_tag_row("old-name")).not_to_be_visible()

        # Verify the tag was updated in the database
        tag.refresh_from_db()
        self.assertEqual(tag.name, "new-name")

    def test_edit_tag_validation_error(self):
        tag = self.setup_tag(name="tag-to-edit")
        other_tag = self.setup_tag(name="other-tag")

        self.open(reverse("linkding:tags.index"))

        # Click the Edit button for the tag
        tag_row = self.locate_tag_row(tag.name)
        tag_row.get_by_role("link", name="Edit").click()

        modal = self.locate_tag_modal()

        # Clear the name and submit
        name_input = modal.get_by_label("Name")
        name_input.fill("")
        modal.get_by_text("Save").click()

        # Verify the error is shown (field is required)
        error_hint = modal.get_by_text("This field is required")
        expect(error_hint).to_be_visible()

        # Fill in the name of another existing tag
        name_input.fill(other_tag.name)
        modal.get_by_text("Save").click()

        # Verify the error is shown (tag already exists)
        error_hint = modal.get_by_text('Tag "other-tag" already exists')
        expect(error_hint).to_be_visible()

        # Verify the tag was not modified
        tag.refresh_from_db()
        self.assertEqual(tag.name, "tag-to-edit")

    def test_edit_tag_preserves_query_and_scroll_position(self):
        # Create enough tags to have multiple pages (50 per page)
        for i in range(70):
            self.setup_tag(name=f"test-tag-{i:02d}")

        # Open tags page 2 with search query
        url = reverse("linkding:tags.index") + "?search=test&page=2"
        self.open(url)

        # Verify we're on page 2
        expect(self.locate_tag_row("test-tag-00")).not_to_be_visible()
        expect(self.locate_tag_row("test-tag-50")).to_be_visible()
        expect(self.locate_tag_row("test-tag-60")).to_be_visible()

        # Scroll down
        self.page.evaluate("window.scrollTo(0, 300)")
        initial_scroll = self.page.evaluate("window.scrollY")
        self.assertGreater(initial_scroll, 0)

        # Edit tag
        tag_row = self.locate_tag_row("test-tag-55")
        tag_row.get_by_role("link", name="Edit").click()

        modal = self.locate_tag_modal()

        name_input = modal.get_by_label("Name")
        name_input.fill("test-tag-55-edited")

        modal.get_by_text("Save").click()

        expect(modal).not_to_be_visible()

        # Verify query parameters and scroll position are preserved
        current_url = self.page.url
        self.assertIn("search=test", current_url)
        self.assertIn("page=2", current_url)

        expect(self.locate_tag_row("test-tag-00")).not_to_be_visible()
        expect(self.locate_tag_row("test-tag-50")).to_be_visible()
        expect(self.locate_tag_row("test-tag-55-edited")).to_be_visible()
        expect(self.locate_tag_row("test-tag-60")).to_be_visible()

        final_scroll = self.page.evaluate("window.scrollY")
        self.assertEqual(initial_scroll, final_scroll)

    def test_delete_tag_preserves_query_and_scroll_position(self):
        # Create enough tags to have multiple pages (50 per page)
        for i in range(70):
            self.setup_tag(name=f"test-tag-{i:02d}")

        # Open tags page 2 with search query
        url = reverse("linkding:tags.index") + "?search=test&page=2"
        self.open(url)

        # Verify we're on page 2
        expect(self.locate_tag_row("test-tag-00")).not_to_be_visible()
        expect(self.locate_tag_row("test-tag-50")).to_be_visible()
        expect(self.locate_tag_row("test-tag-55")).to_be_visible()
        expect(self.locate_tag_row("test-tag-60")).to_be_visible()

        # Scroll down
        self.page.evaluate("window.scrollTo(0, 300)")
        initial_scroll = self.page.evaluate("window.scrollY")
        self.assertGreater(initial_scroll, 0)

        # Delete tag
        tag_row = self.locate_tag_row("test-tag-55")
        tag_row.get_by_role("button", name="Remove").click()
        self.locate_confirm_dialog().get_by_text("Confirm").click()

        # Verify query parameters and scroll position are preserved
        current_url = self.page.url
        self.assertIn("search=test", current_url)
        self.assertIn("page=2", current_url)

        expect(self.locate_tag_row("test-tag-00")).not_to_be_visible()
        expect(self.locate_tag_row("test-tag-50")).to_be_visible()
        expect(self.locate_tag_row("test-tag-55")).not_to_be_visible()
        expect(self.locate_tag_row("test-tag-60")).to_be_visible()

        final_scroll = self.page.evaluate("window.scrollY")
        self.assertEqual(initial_scroll, final_scroll)

    def test_merge_tags(self):
        target_tag = self.setup_tag(name="target-tag")
        merge_tag1 = self.setup_tag(name="merge-tag1")
        merge_tag2 = self.setup_tag(name="merge-tag2")

        # Create bookmarks with the merge tags
        bookmark1 = self.setup_bookmark(tags=[merge_tag1])
        bookmark2 = self.setup_bookmark(tags=[merge_tag2])

        self.open(reverse("linkding:tags.index"))

        # Click the Merge Tags button to open the modal
        self.page.get_by_text("Merge Tags", exact=True).click()

        modal = self.locate_merge_modal()

        # Fill in the target tag
        target_input = modal.get_by_label("Target tag")
        target_input.fill(target_tag.name)

        # Fill in the tags to merge
        merge_input = modal.get_by_label("Tags to merge")
        merge_input.fill(f"{merge_tag1.name} {merge_tag2.name}")

        # Submit the form
        modal.get_by_role("button", name="Merge Tags").click()

        # Verify modal is closed
        expect(modal).not_to_be_visible()

        # Verify the success message is shown
        self.verify_success_message(
            'Successfully merged 2 tags (merge-tag1, merge-tag2) into "target-tag".'
        )

        # Verify the merged tags are no longer in the list
        expect(self.locate_tag_row("target-tag")).to_be_visible()
        expect(self.locate_tag_row("merge-tag1")).not_to_be_visible()
        expect(self.locate_tag_row("merge-tag2")).not_to_be_visible()

        # Verify the merge tags were deleted
        self.assertEqual(
            Tag.objects.filter(owner=self.get_or_create_test_user()).count(), 1
        )

        # Verify bookmarks only have the target tag
        bookmark1.refresh_from_db()
        bookmark2.refresh_from_db()
        self.assertCountEqual([target_tag], bookmark1.tags.all())
        self.assertCountEqual([target_tag], bookmark2.tags.all())

    def test_merge_tags_validation_error(self):
        target_tag = self.setup_tag(name="target-tag")
        merge_tag = self.setup_tag(name="merge-tag")

        self.open(reverse("linkding:tags.index"))

        # Click the Merge Tags button to open the modal
        self.page.get_by_text("Merge Tags", exact=True).click()

        modal = self.locate_merge_modal()

        # Submit with empty values
        modal.get_by_role("button", name="Merge Tags").click()

        # Verify the errors are shown
        expect(modal.get_by_text("This field is required").first).to_be_visible()

        # Fill in non-existent target tag
        target_input = modal.get_by_label("Target tag")
        target_input.fill("nonexistent-tag")

        merge_input = modal.get_by_label("Tags to merge")
        merge_input.fill(merge_tag.name)

        modal.get_by_role("button", name="Merge Tags").click()

        # Verify error for non-existent target tag
        expect(
            modal.get_by_text('Tag "nonexistent-tag" does not exist')
        ).to_be_visible()

        # Fill in valid target but target tag in merge tags
        target_input.fill(target_tag.name)
        merge_input.fill(target_tag.name)

        modal.get_by_role("button", name="Merge Tags").click()

        # Verify error for target tag in merge tags
        expect(
            modal.get_by_text("The target tag cannot be selected for merging")
        ).to_be_visible()

        # Verify no tags were deleted
        self.assertEqual(
            Tag.objects.filter(owner=self.get_or_create_test_user()).count(), 2
        )

    def test_search_updates_url_query_params(self):
        self.setup_tag(name="python")
        self.setup_tag(name="javascript")
        self.setup_tag(name="typescript")

        self.open(reverse("linkding:tags.index"))

        # Verify all tags are visible initially
        expect(self.locate_tag_row("python")).to_be_visible()
        expect(self.locate_tag_row("javascript")).to_be_visible()
        expect(self.locate_tag_row("typescript")).to_be_visible()

        # Enter search term and submit
        search_input = self.page.get_by_placeholder("Search tags...")
        search_input.fill("script")
        self.page.get_by_role("button", name="Search").click()

        # Wait for filtered results to appear
        expect(self.locate_tag_row("python")).not_to_be_visible()
        expect(self.locate_tag_row("javascript")).to_be_visible()
        expect(self.locate_tag_row("typescript")).to_be_visible()

        # Verify URL contains search query param
        self.assertIn("search=script", self.page.url)


================================================
FILE: bookmarks/tests_e2e/helpers.py
================================================
import os

from django.contrib.staticfiles.testing import LiveServerTestCase
from playwright.sync_api import BrowserContext, Page, expect, sync_playwright

from bookmarks.tests.helpers import BookmarkFactoryMixin

SCREENSHOT_DIR = "test-results/screenshots"

# Allow Django ORM operations within Playwright's async context
os.environ.setdefault("DJANGO_ALLOW_ASYNC_UNSAFE", "true")


class LinkdingE2ETestCase(LiveServerTestCase, BookmarkFactoryMixin):
    def setUp(self) -> None:
        self.client.force_login(self.get_or_create_test_user())
        self.cookie = self.client.cookies["sessionid"]
        self.playwright = None
        self.browser = None
        self.context = None
        self.page = None

    def tearDown(self) -> None:
        if self.page and self._test_has_failed():
            self._capture_screenshot()
        if self.browser:
            self.browser.close()
        if self.playwright:
            self.playwright.stop()
        super().tearDown()

    def _test_has_failed(self) -> bool:
        """Detect if the current test has failed. Works with both Django/unittest and pytest."""
        # Check _outcome for failure info
        if self._outcome is not None:
            result = self._outcome.result
            if result:
                # pytest stores exception info in _excinfo
                if hasattr(result, "_excinfo") and result._excinfo:
                    return True
                # Django/unittest stores failures and errors in the result
                # Check if THIS test is in failures/errors (not just any test)
                if hasattr(result, "failures"):
                    for failed_test, _ in result.failures:
                        if failed_test is self:
                            return True
        return False

    def _ensure_playwright(self):
        if not self.playwright:
            self.playwright = sync_playwright().start()
            self.browser = self.playwright.chromium.launch(headless=True)

    def _capture_screenshot(self):
        os.makedirs(SCREENSHOT_DIR, exist_ok=True)
        filename = f"{self.__class__.__name__}_{self._testMethodName}.png"
        filepath = os.path.join(SCREENSHOT_DIR, filename)
        self.page.screenshot(path=filepath, full_page=True)

    def setup_browser(self) -> BrowserContext:
        self._ensure_playwright()
        context = self.browser.new_context()
        context.add_cookies(
            [
                {
                    "name": "sessionid",
                    "value": self.cookie.value,
                    "domain": self.live_server_url.replace("http:", ""),
                    "path": "/",
                }
            ]
        )
        return context

    def open(self, url: str) -> Page:
        self.context = self.setup_browser()
        self.page = self.context.new_page()
        self.page.on("pageerror", self.on_page_error)
        self.page.goto(self.live_server_url + url)
        self.page.on("load", self.on_load)
        self.num_loads = 0
        return self.page

    def on_page_error(self, error):
        print(f"[JS ERROR] {error}")
        if hasattr(error, "stack"):
            print(f"[JS STACK] {error.stack}")

    def on_load(self):
        self.num_loads += 1

    def assertReloads(self, count: int):
        self.assertEqual(self.num_loads, count)

    def resetReloads(self):
        self.num_loads = 0

    def locate_bookmark_list(self):
        return self.page.locator("ul.bookmark-list")

    def locate_bookmark(self, title: str):
        bookmark_tags = self.page.locator("ul.bookmark-list > li")
        return bookmark_tags.filter(has_text=title)

    def count_bookmarks(self):
        bookmark_tags = self.page.locator("ul.bookmark-list > li")
        return bookmark_tags.count()

    def locate_details_modal(self):
        return self.page.locator("ld-details-modal")

    def open_details_modal(self, bookmark):
        details_button = self.locate_bookmark(bookmark.title).get_by_text("View")
        details_button.click()

        details_modal = self.locate_details_modal()
        expect(details_modal).to_be_visible()

        return details_modal

    def locate_bulk_edit_bar(self):
        return self.page.locator(".bulk-edit-bar")

    def locate_bulk_edit_select_all(self):
        return self.locate_bulk_edit_bar().locator("label.bulk-edit-checkbox.all")

    def locate_bulk_edit_select_across(self):
        return self.locate_bulk_edit_bar().locator("label.select-across")

    def locate_bulk_edit_toggle(self):
        return self.page.get_by_title("Bulk edit")

    def select_bulk_action(self, value: str):
        return (
            self.locate_bulk_edit_bar()
            .locator('select[name="bulk_action"]')
            .select_option(value)
        )

    def navigate_menu(self, main_menu_item: str, sub_menu_item: str | None = None):
        if sub_menu_item:
            self.page.locator("nav").get_by_role("button", name=main_menu_item).click()
            self.page.locator("nav ul.menu").get_by_text(
                sub_menu_item, exact=True
            ).click()
        else:
            self.page.locator("nav").get_by_text(main_menu_item, exact=True).click()

    def locate_confirm_dialog(self):
        return self.page.locator("ld-confirm-dropdown")


================================================
FILE: bookmarks/type_defs.py
================================================
"""
Stuff in here is only used for type hints
"""

from django import http
from django.contrib.auth.models import AnonymousUser

from bookmarks.models import GlobalSettings, User, UserProfile


class HttpRequest(http.HttpRequest):
    global_settings: GlobalSettings
    user_profile: UserProfile
    user: User | AnonymousUser


================================================
FILE: bookmarks/urls.py
================================================
from django.conf import settings
from django.contrib.auth import views as django_auth_views
from django.urls import include, path, re_path

from bookmarks import feeds
from bookmarks.admin import linkding_admin_site
from bookmarks.api import routes as api_routes
from bookmarks.views import assets as assets_views
from bookmarks.views import auth as linkding_auth_views
from bookmarks.views import bookmarks as bookmarks_views
from bookmarks.views import bundles as bundles_views
from bookmarks.views import settings as settings_views
from bookmarks.views import tags as tags_views
from bookmarks.views import toasts as toasts_views
from bookmarks.views.custom_css import custom_css as custom_css_view
from bookmarks.views.health import health as health_view
from bookmarks.views.manifest import manifest as manifest_view
from bookmarks.views.opensearch import opensearch as opensearch_view
from bookmarks.views.root import root as root_view

urlpatterns = [
    # Root view handling redirection based on user authentication
    re_path(r"^$", root_view, name="root"),
    # Bookmarks
    path("bookmarks", bookmarks_views.index, name="bookmarks.index"),
    path(
        "bookmarks/action", bookmarks_views.index_action, name="bookmarks.index.action"
    ),
    path("bookmarks/archived", bookmarks_views.archived, name="bookmarks.archived"),
    path(
        "bookmarks/archived/action",
        bookmarks_views.archived_action,
        name="bookmarks.archived.action",
    ),
    path("bookmarks/shared", bookmarks_views.shared, name="bookmarks.shared"),
    path(
        "bookmarks/shared/action",
        bookmarks_views.shared_action,
        name="bookmarks.shared.action",
    ),
    path("bookmarks/new", bookmarks_views.new, name="bookmarks.new"),
    path("bookmarks/close", bookmarks_views.close, name="bookmarks.close"),
    path(
        "bookmarks/<int:bookmark_id>/edit", bookmarks_views.edit, name="bookmarks.edit"
    ),
    # Assets
    path(
        "assets/<int:asset_id>",
        assets_views.view,
        name="assets.view",
    ),
    path(
        "assets/<int:asset_id>/read",
        assets_views.read,
        name="assets.read",
    ),
    # Bundles
    path("bundles", bundles_views.index, name="bundles.index"),
    path("bundles/action", bundles_views.action, name="bundles.action"),
    path("bundles/new", bundles_views.new, name="bundles.new"),
    path("bundles/<int:bundle_id>/edit", bundles_views.edit, name="bundles.edit"),
    path("bundles/preview", bundles_views.preview, name="bundles.preview"),
    # Tags
    path("tags", tags_views.tags_index, name="tags.index"),
    path("tags/new", tags_views.tag_new, name="tags.new"),
    path("tags/<int:tag_id>/edit", tags_views.tag_edit, name="tags.edit"),
    path("tags/merge", tags_views.tag_merge, name="tags.merge"),
    # Settings
    path("settings", settings_views.general, name="settings.index"),
    path("settings/general", settings_views.general, name="settings.general"),
    path("settings/update", settings_views.update, name="settings.update"),
    path(
        "settings/integrations",
        settings_views.integrations,
        name="settings.integrations",
    ),
    path(
        "settings/integrations/create-api-token",
        settings_views.create_api_token,
        name="settings.integrations.create_api_token",
    ),
    path(
        "settings/integrations/delete-api-token",
        settings_views.delete_api_token,
        name="settings.integrations.delete_api_token",
    ),
    path("settings/import", settings_views.bookmark_import, name="settings.import"),
    path("settings/export", settings_views.bookmark_export, name="settings.export"),
    # Toasts
    path("toasts/acknowledge", toasts_views.acknowledge, name="toasts.acknowledge"),
    # API
    path("api/", include(api_routes.default_router.urls)),
    path("api/bookmarks/", include(api_routes.bookmark_router.urls)),
    path(
        "api/bookmarks/<int:bookmark_id>/assets/",
        include(api_routes.bookmark_asset_router.urls),
    ),
    path("api/tags/", include(api_routes.tag_router.urls)),
    path("api/bundles/", include(api_routes.bundle_router.urls)),
    path("api/user/", include(api_routes.user_router.urls)),
    # Feeds
    path("feeds/<str:feed_key>/all", feeds.AllBookmarksFeed(), name="feeds.all"),
    path(
        "feeds/<str:feed_key>/unread", feeds.UnreadBookmarksFeed(), name="feeds.unread"
    ),
    path(
        "feeds/<str:feed_key>/shared", feeds.SharedBookmarksFeed(), name="feeds.shared"
    ),
    path("feeds/shared", feeds.PublicSharedBookmarksFeed(), name="feeds.public_shared"),
    # Health check
    path("health", health_view, name="health"),
    # Manifest
    path("manifest.json", manifest_view, name="manifest"),
    # Custom CSS
    path("custom_css", custom_css_view, name="custom_css"),
    # OpenSearch
    path("opensearch.xml", opensearch_view, name="opensearch"),
]

# Live reload (debug only)
if settings.DEBUG:
    from bookmarks.views import reload

    urlpatterns.append(path("live_reload", reload.live_reload, name="live_reload"))

# Put all linkding URLs into a linkding namespace
urlpatterns = [path("", include((urlpatterns, "linkding")))]

# Auth
urlpatterns += [
    path(
        "login/",
        linkding_auth_views.LinkdingLoginView.as_view(redirect_authenticated_user=True),
        name="login",
    ),
    path("logout/", django_auth_views.LogoutView.as_view(), name="logout"),
    path(
        "change-password/",
        linkding_auth_views.LinkdingPasswordChangeView.as_view(),
        name="change_password",
    ),
    path(
        "password-change-done/",
        django_auth_views.PasswordChangeDoneView.as_view(),
        name="password_change_done",
    ),
]

# Admin
urlpatterns.append(path("admin/", linkding_admin_site.urls))

# OIDC
if settings.LD_ENABLE_OIDC:
    urlpatterns.append(path("oidc/", include("mozilla_django_oidc.urls")))

# Debug toolbar
# if settings.DEBUG:
#    import debug_toolbar
#    urlpatterns.append(path("__debug__/", include(debug_toolbar.urls)))

# Context path
if settings.LD_CONTEXT_PATH:
    urlpatterns = [path(settings.LD_CONTEXT_PATH, include(urlpatterns))]


================================================
FILE: bookmarks/utils.py
================================================
import datetime
import logging
import re
import unicodedata
import urllib.parse
from dataclasses import dataclass

from django.conf import settings
from django.http import HttpResponseRedirect
from django.template.defaultfilters import pluralize
from django.utils import formats, timezone

try:
    with open("version.txt") as f:
        app_version = f.read().strip("\n")
except Exception as exc:
    logging.exception(exc)
    app_version = ""


def unique(elements, key):
    return list({key(element): element for element in elements}.values())


weekday_names = {
    1: "Monday",
    2: "Tuesday",
    3: "Wednesday",
    4: "Thursday",
    5: "Friday",
    6: "Saturday",
    7: "Sunday",
}


@dataclass
class DateDelta:
    years: int
    months: int
    weeks: int


def _calculate_date_delta(
    now: datetime.datetime, value: datetime.datetime
) -> DateDelta:
    """Calculate the difference between two datetimes in years, months, and weeks."""
    # Full calendar years
    years = now.year - value.year
    if (now.month, now.day) < (value.month, value.day):
        years -= 1

    # Full calendar months
    months = (now.year - value.year) * 12 + (now.month - value.month)
    if now.day < value.day:
        months -= 1

    # Weeks from total days
    weeks = (now - value).days // 7

    return DateDelta(years=max(0, years), months=max(0, months), weeks=max(0, weeks))


def humanize_absolute_date(
    value: datetime.datetime, now: datetime.datetime | None = None
):
    if not now:
        now = timezone.now()
    delta = _calculate_date_delta(now, value)
    yesterday = now - datetime.timedelta(days=1)

    is_older_than_a_week = delta.years > 0 or delta.months > 0 or delta.weeks > 0

    if is_older_than_a_week:
        return formats.date_format(value, "SHORT_DATE_FORMAT")
    elif value.day == now.day:
        return "Today"
    elif value.day == yesterday.day:
        return "Yesterday"
    else:
        return weekday_names[value.isoweekday()]


def humanize_relative_date(
    value: datetime.datetime, now: datetime.datetime | None = None
):
    if not now:
        now = timezone.now()
    delta = _calculate_date_delta(now, value)

    if delta.years > 0:
        return f"{delta.years} year{pluralize(delta.years)} ago"
    elif delta.months > 0:
        return f"{delta.months} month{pluralize(delta.months)} ago"
    elif delta.weeks > 0:
        return f"{delta.weeks} week{pluralize(delta.weeks)} ago"
    else:
        yesterday = now - datetime.timedelta(days=1)
        if value.day == now.day:
            return "Today"
        elif value.day == yesterday.day:
            return "Yesterday"
        else:
            return weekday_names[value.isoweekday()]


def parse_timestamp(value: str):
    """
    Parses a string timestamp into a datetime value
    First tries to parse the timestamp as milliseconds.
    If that fails with an error indicating that the timestamp exceeds the maximum,
    it tries to parse the timestamp as microseconds, and then as nanoseconds
    :param value:
    :return:
    """
    try:
        timestamp = int(value)
    except ValueError:
        raise ValueError(f"{value} is not a valid timestamp") from None

    try:
        return datetime.datetime.fromtimestamp(timestamp, datetime.UTC)
    except (OverflowError, ValueError, OSError):
        pass

    # Value exceeds the max. allowed timestamp
    # Try parsing as microseconds
    try:
        return datetime.datetime.fromtimestamp(timestamp / 1000, datetime.UTC)
    except (OverflowError, ValueError, OSError):
        pass

    # Value exceeds the max. allowed timestamp
    # Try parsing as nanoseconds
    try:
        return datetime.datetime.fromtimestamp(timestamp / 1000000, datetime.UTC)
    except (OverflowError, ValueError, OSError):
        pass

    # Timestamp is out of range
    raise ValueError(f"{value} exceeds maximum value for a timestamp")


def get_safe_return_url(return_url: str, fallback_url: str):
    # Use fallback if URL is none or URL is not on same domain
    if not return_url or not re.match(r"^/[a-z]+", return_url):
        return fallback_url
    return return_url


def redirect_with_query(request, redirect_url):
    query_string = urllib.parse.urlencode(request.GET)
    if query_string:
        redirect_url += "?" + query_string

    return HttpResponseRedirect(redirect_url)


def generate_username(email, claims):
    # taken from mozilla-django-oidc docs :)
    # Using Python 3 and Django 1.11+, usernames can contain alphanumeric
    # (ascii and unicode), _, @, +, . and - characters. So we normalize
    # it and slice at 150 characters.
    if settings.OIDC_USERNAME_CLAIM in claims and claims[settings.OIDC_USERNAME_CLAIM]:
        username = claims[settings.OIDC_USERNAME_CLAIM]
    else:
        username = email
    return unicodedata.normalize("NFKC", username)[:150]


def normalize_url(url: str) -> str:
    if not url or not isinstance(url, str):
        return ""

    url = url.strip()
    if not url:
        return ""

    try:
        parsed = urllib.parse.urlparse(url)

        # Normalize the scheme to lowercase
        scheme = parsed.scheme.lower()

        # Normalize the netloc (domain) to lowercase
        netloc = parsed.hostname.lower() if parsed.hostname else ""
        if parsed.port:
            netloc += f":{parsed.port}"
        if parsed.username:
            auth = parsed.username
            if parsed.password:
                auth += f":{parsed.password}"
            netloc = f"{auth}@{netloc}"

        # Remove trailing slashes from all paths
        path = parsed.path.rstrip("/") if parsed.path else ""

        # Sort query parameters alphabetically
        query = ""
        if parsed.query:
            query_params = urllib.parse.parse_qsl(parsed.query, keep_blank_values=True)
            query_params.sort(key=lambda x: (x[0], x[1]))
            query = urllib.parse.urlencode(query_params, quote_via=urllib.parse.quote)

        # Keep fragment as-is
        fragment = parsed.fragment

        # Reconstruct the normalized URL
        return urllib.parse.urlunparse(
            (scheme, netloc, path, parsed.params, query, fragment)
        )

    except (ValueError, AttributeError):
        return url


================================================
FILE: bookmarks/validators.py
================================================
from django.conf import settings
from django.core import validators


class BookmarkURLValidator(validators.URLValidator):
    """
    Extends default Django URLValidator and cancels validation if it is disabled in settings.
    This allows to switch URL validation on/off dynamically which helps with testing
    """

    def __call__(self, value):
        if settings.LD_DISABLE_URL_VALIDATION:
            return

        super().__call__(value)


================================================
FILE: bookmarks/views/__init__.py
================================================


================================================
FILE: bookmarks/views/access.py
================================================
from django.http import Http404

from bookmarks.models import ApiToken, Bookmark, BookmarkAsset, BookmarkBundle, Toast
from bookmarks.type_defs import HttpRequest


def bookmark_read(request: HttpRequest, bookmark_id: int | str):
    try:
        bookmark = Bookmark.objects.get(pk=int(bookmark_id))
    except Bookmark.DoesNotExist:
        raise Http404("Bookmark does not exist") from None

    is_owner = bookmark.owner == request.user
    is_shared = (
        request.user.is_authenticated
        and bookmark.shared
        and bookmark.owner.profile.enable_sharing
    )
    is_public_shared = bookmark.shared and bookmark.owner.profile.enable_public_sharing
    if not is_owner and not is_shared and not is_public_shared:
        raise Http404("Bookmark does not exist")
    if request.method == "POST" and not is_owner:
        raise Http404("Bookmark does not exist")

    return bookmark


def bookmark_write(request: HttpRequest, bookmark_id: int | str):
    try:
        return Bookmark.objects.get(pk=bookmark_id, owner=request.user)
    except Bookmark.DoesNotExist:
        raise Http404("Bookmark does not exist") from None


def bundle_read(request: HttpRequest, bundle_id: int | str):
    return bundle_write(request, bundle_id)


def bundle_write(request: HttpRequest, bundle_id: int | str):
    try:
        return BookmarkBundle.objects.get(pk=bundle_id, owner=request.user)
    except (BookmarkBundle.DoesNotExist, ValueError):
        raise Http404("Bundle does not exist") from None


def asset_read(request: HttpRequest, asset_id: int | str):
    try:
        asset = BookmarkAsset.objects.get(pk=asset_id)
    except BookmarkAsset.DoesNotExist:
        raise Http404("Asset does not exist") from None

    bookmark_read(request, asset.bookmark_id)
    return asset


def asset_write(request: HttpRequest, asset_id: int | str):
    try:
        return BookmarkAsset.objects.get(pk=asset_id, bookmark__owner=request.user)
    except BookmarkAsset.DoesNotExist:
        raise Http404("Asset does not exist") from None


def toast_write(request: HttpRequest, toast_id: int | str):
    try:
        return Toast.objects.get(pk=toast_id, owner=request.user)
    except Toast.DoesNotExist:
        raise Http404("Toast does not exist") from None


def api_token_write(request: HttpRequest, token_id: int | str):
    try:
        return ApiToken.objects.get(id=token_id, user=request.user)
    except (ApiToken.DoesNotExist, ValueError):
        raise Http404("API token does not exist") from None


================================================
FILE: bookmarks/views/assets.py
================================================
import gzip
import os

from django.conf import settings
from django.http import (
    Http404,
    HttpResponse,
)
from django.shortcuts import render

from bookmarks.views import access


def _get_asset_content(asset):
    filepath = os.path.join(settings.LD_ASSET_FOLDER, asset.file)

    if not os.path.exists(filepath):
        raise Http404("Asset file does not exist")

    if asset.gzip:
        with gzip.open(filepath, "rb") as f:
            content = f.read()
    else:
        with open(filepath, "rb") as f:
            content = f.read()

    return content


def view(request, asset_id: int):
    asset = access.asset_read(request, asset_id)
    content = _get_asset_content(asset)

    response = HttpResponse(content, content_type=asset.content_type)
    response["Content-Disposition"] = f'inline; filename="{asset.download_name}"'
    if asset.content_type and asset.content_type.startswith("video/"):
        response["Content-Security-Policy"] = "default-src 'none'; media-src 'self';"
    elif asset.content_type == "application/pdf":
        response["Content-Security-Policy"] = "default-src 'none'; object-src 'self';"
    else:
        response["Content-Security-Policy"] = "sandbox allow-scripts"
    return response


def read(request, asset_id: int):
    asset = access.asset_read(request, asset_id)
    content = _get_asset_content(asset)
    content = content.decode("utf-8")

    return render(
        request,
        "bookmarks/read.html",
        {
            "content": content,
        },
    )


================================================
FILE: bookmarks/views/auth.py
================================================
from django.conf import settings
from django.contrib.auth import views as auth_views

from bookmarks.widgets import FormErrorList


class LinkdingLoginView(auth_views.LoginView):
    """
    Custom login view to lazily add additional context data
    Allows to override settings in tests
    """

    def get_form(self, form_class=None):
        form = super().get_form(form_class)
        form.error_class = FormErrorList
        return form

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)

        context["enable_oidc"] = settings.LD_ENABLE_OIDC
        context["disable_login"] = settings.LD_DISABLE_LOGIN_FORM
        return context

    def form_invalid(self, form):
        """
        Return 401 status code on failed login. Should allow integrating with
        tools like Fail2Ban. Also, Hotwired Turbo requires a non 2xx status
        code to handle failed form submissions.
        """
        response = super().form_invalid(form)
        response.status_code = 401
        return response


class LinkdingPasswordChangeView(auth_views.PasswordChangeView):
    def get_form(self, form_class=None):
        form = super().get_form(form_class)
        form.error_class = FormErrorList
        return form

    def form_invalid(self, form):
        """
        Hotwired Turbo requires a non 2xx status code to handle failed form
        submissions.
        """
        response = super().form_invalid(form)
        response.status_code = 422
        return response


================================================
FILE: bookmarks/views/bookmarks.py
================================================
import urllib.parse

from django.conf import settings
from django.contrib.auth.decorators import login_required
from django.db.models import QuerySet
from django.http import (
    HttpResponseBadRequest,
    HttpResponseForbidden,
    HttpResponseRedirect,
)
from django.shortcuts import render
from django.urls import reverse

from bookmarks import queries, utils
from bookmarks.forms import BookmarkForm
from bookmarks.models import (
    Bookmark,
    BookmarkSearch,
)
from bookmarks.services import assets as asset_actions
from bookmarks.services import tasks
from bookmarks.services.bookmarks import (
    archive_bookmark,
    archive_bookmarks,
    create_html_snapshots,
    delete_bookmarks,
    mark_bookmarks_as_read,
    mark_bookmarks_as_unread,
    refresh_bookmarks_metadata,
    share_bookmarks,
    tag_bookmarks,
    unarchive_bookmark,
    unarchive_bookmarks,
    unshare_bookmarks,
    untag_bookmarks,
)
from bookmarks.type_defs import HttpRequest
from bookmarks.utils import get_safe_return_url
from bookmarks.views import access, contexts, turbo


@login_required
def index(request: HttpRequest):
    if request.method == "POST":
        return search_action(request)

    search = BookmarkSearch.from_request(
        request, request.GET, request.user_profile.search_preferences
    )
    bookmark_list = contexts.ActiveBookmarkListContext(request, search)
    bundles = contexts.BundlesContext(request)
    tag_cloud = contexts.ActiveTagCloudContext(request, search)
    bookmark_details = contexts.get_details_context(
        request, contexts.ActiveBookmarkDetailsContext
    )

    return render_bookmarks_view(
        request,
        {
            "page_title": "Bookmarks - Linkding",
            "bookmark_list": bookmark_list,
            "bundles": bundles,
            "tag_cloud": tag_cloud,
            "details": bookmark_details,
        },
    )


def index_update(request: HttpRequest):
    search = BookmarkSearch.from_request(
        request, request.GET, request.user_profile.search_preferences
    )
    bookmark_list = contexts.ActiveBookmarkListContext(request, search)
    tag_cloud = contexts.ActiveTagCloudContext(request, search)
    details = contexts.get_details_context(
        request, contexts.ActiveBookmarkDetailsContext
    )
    return render_bookmarks_update(request, bookmark_list, tag_cloud, details)


@login_required
def archived(request: HttpRequest):
    if request.method == "POST":
        return search_action(request)

    search = BookmarkSearch.from_request(
        request, request.GET, request.user_profile.search_preferences
    )
    bookmark_list = contexts.ArchivedBookmarkListContext(request, search)
    bundles = contexts.BundlesContext(request)
    tag_cloud = contexts.ArchivedTagCloudContext(request, search)
    bookmark_details = contexts.get_details_context(
        request, contexts.ArchivedBookmarkDetailsContext
    )

    return render_bookmarks_view(
        request,
        {
            "page_title": "Archived bookmarks - Linkding",
            "bookmark_list": bookmark_list,
            "bundles": bundles,
            "tag_cloud": tag_cloud,
            "details": bookmark_details,
        },
    )


def archived_update(request: HttpRequest):
    search = BookmarkSearch.from_request(
        request, request.GET, request.user_profile.search_preferences
    )
    bookmark_list = contexts.ArchivedBookmarkListContext(request, search)
    tag_cloud = contexts.ArchivedTagCloudContext(request, search)
    details = contexts.get_details_context(
        request, contexts.ArchivedBookmarkDetailsContext
    )
    return render_bookmarks_update(request, bookmark_list, tag_cloud, details)


def shared(request: HttpRequest):
    if request.method == "POST":
        return search_action(request)

    search = BookmarkSearch.from_request(
        request, request.GET, request.user_profile.search_preferences
    )
    bookmark_list = contexts.SharedBookmarkListContext(request, search)
    tag_cloud = contexts.SharedTagCloudContext(request, search)
    bookmark_details = contexts.get_details_context(
        request, contexts.SharedBookmarkDetailsContext
    )
    user_list = contexts.UserListContext(request, search)
    return render_bookmarks_view(
        request,
        {
            "page_title": "Shared bookmarks - Linkding",
            "bookmark_list": bookmark_list,
            "tag_cloud": tag_cloud,
            "details": bookmark_details,
            "user_list": user_list,
            "rss_feed_url": reverse("linkding:feeds.public_shared"),
        },
    )


def shared_update(request: HttpRequest):
    search = BookmarkSearch.from_request(
        request, request.GET, request.user_profile.search_preferences
    )
    bookmark_list = contexts.SharedBookmarkListContext(request, search)
    tag_cloud = contexts.SharedTagCloudContext(request, search)
    details = contexts.get_details_context(
        request, contexts.SharedBookmarkDetailsContext
    )
    return render_bookmarks_update(request, bookmark_list, tag_cloud, details)


def render_bookmarks_view(request: HttpRequest, context):
    if context["details"]:
        context["page_title"] = "Bookmark details - Linkding"

    if turbo.is_frame(request, "details-modal"):
        return turbo.frame(request, "bookmarks/details/modal.html", context)

    return render(
        request,
        "bookmarks/bookmark_page.html",
        context,
    )


def render_bookmarks_update(request, bookmark_list, tag_cloud, details):
    return turbo.stream(
        turbo.update(
            request,
            "bookmark-list-container",
            "bookmarks/bookmark_list.html",
            {"bookmark_list": bookmark_list},
        ),
        turbo.update(
            request,
            "tag-cloud-container",
            "bookmarks/tag_cloud.html",
            {"tag_cloud": tag_cloud},
        ),
        turbo.replace(
            request,
            "details-modal",
            "bookmarks/details/modal.html",
            {"details": details},
            method="morph",
        ),
    )


def search_action(request: HttpRequest):
    if "save" in request.POST:
        if not request.user.is_authenticated:
            return HttpResponseForbidden()
        search = BookmarkSearch.from_request(request, request.POST)
        request.user_profile.search_preferences = search.preferences_dict
        request.user_profile.save()

    # redirect to base url including new query params
    search = BookmarkSearch.from_request(
        request, request.POST, request.user_profile.search_preferences
    )
    base_url = request.path
    query_params = search.query_params
    query_string = urllib.parse.urlencode(query_params)
    url = base_url if not query_string else base_url + "?" + query_string
    return HttpResponseRedirect(url)


def convert_tag_string(tag_string: str):
    # Tag strings coming from inputs are space-separated, however services.bookmarks functions expect comma-separated
    # strings
    return tag_string.replace(" ", ",")


@login_required
def new(request: HttpRequest):
    form = BookmarkForm(request)
    if request.method == "POST" and form.is_valid():
        form.save()
        if form.is_auto_close:
            return HttpResponseRedirect(reverse("linkding:bookmarks.close"))
        else:
            return HttpResponseRedirect(reverse("linkding:bookmarks.index"))

    status = 422 if request.method == "POST" and not form.is_valid() else 200
    context = {"form": form, "return_url": reverse("linkding:bookmarks.index")}

    return render(request, "bookmarks/new.html", context, status=status)


@login_required
def edit(request: HttpRequest, bookmark_id: int):
    bookmark = access.bookmark_write(request, bookmark_id)
    form = BookmarkForm(request, instance=bookmark)
    return_url = get_safe_return_url(
        request.GET.get("return_url"), reverse("linkding:bookmarks.index")
    )

    if request.method == "POST" and form.is_valid():
        form.save()
        return HttpResponseRedirect(return_url)

    status = 422 if request.method == "POST" and not form.is_valid() else 200
    context = {"form": form, "bookmark_id": bookmark_id, "return_url": return_url}

    return render(request, "bookmarks/edit.html", context, status=status)


def remove(request: HttpRequest, bookmark_id: int | str):
    bookmark = access.bookmark_write(request, bookmark_id)
    bookmark.delete()


def archive(request: HttpRequest, bookmark_id: int | str):
    bookmark = access.bookmark_write(request, bookmark_id)
    archive_bookmark(bookmark)


def unarchive(request: HttpRequest, bookmark_id: int | str):
    bookmark = access.bookmark_write(request, bookmark_id)
    unarchive_bookmark(bookmark)


def unshare(request: HttpRequest, bookmark_id: int | str):
    bookmark = access.bookmark_write(request, bookmark_id)
    bookmark.shared = False
    bookmark.save()


def mark_as_read(request: HttpRequest, bookmark_id: int | str):
    bookmark = access.bookmark_write(request, bookmark_id)
    bookmark.unread = False
    bookmark.save()


def create_html_snapshot(request: HttpRequest, bookmark_id: int | str):
    bookmark = access.bookmark_write(request, bookmark_id)
    tasks.create_html_snapshot(bookmark)


def upload_asset(request: HttpRequest, bookmark_id: int | str):
    if settings.LD_DISABLE_ASSET_UPLOAD:
        return HttpResponseForbidden("Asset upload is disabled")

    bookmark = access.bookmark_write(request, bookmark_id)
    file = request.FILES.get("upload_asset_file")
    if not file:
        return HttpResponseBadRequest("No file provided")

    asset_actions.upload_asset(bookmark, file)


def remove_asset(request: HttpRequest, asset_id: int | str):
    asset = access.asset_write(request, asset_id)
    asset_actions.remove_asset(asset)


def update_state(request: HttpRequest, bookmark_id: int | str):
    bookmark = access.bookmark_write(request, bookmark_id)
    bookmark.is_archived = request.POST.get("is_archived") == "on"
    bookmark.unread = request.POST.get("unread") == "on"
    bookmark.shared = request.POST.get("shared") == "on"
    bookmark.save()


@login_required
def index_action(request: HttpRequest):
    search = BookmarkSearch.from_request(
        request, request.GET, request.user_profile.search_preferences
    )
    query = queries.query_bookmarks(request.user, request.user_profile, search)

    response = handle_action(request, query)
    if response:
        return response

    if turbo.accept(request):
        return index_update(request)

    return utils.redirect_with_query(request, reverse("linkding:bookmarks.index"))


@login_required
def archived_action(request: HttpRequest):
    search = BookmarkSearch.from_request(
        request, request.GET, request.user_profile.search_preferences
    )
    query = queries.query_archived_bookmarks(request.user, request.user_profile, search)

    response = handle_action(request, query)
    if response:
        return response

    if turbo.accept(request):
        return archived_update(request)

    return utils.redirect_with_query(request, reverse("linkding:bookmarks.archived"))


@login_required
def shared_action(request: HttpRequest):
    if "bulk_execute" in request.POST:
        return HttpResponseBadRequest("View does not support bulk actions")

    response = handle_action(request)
    if response:
        return response

    if turbo.accept(request):
        return shared_update(request)

    return utils.redirect_with_query(request, reverse("linkding:bookmarks.shared"))


def handle_action(request: HttpRequest, query: QuerySet[Bookmark] = None):
    # Single bookmark actions
    if "archive" in request.POST:
        return archive(request, request.POST["archive"])
    if "unarchive" in request.POST:
        return unarchive(request, request.POST["unarchive"])
    if "remove" in request.POST:
        return remove(request, request.POST["remove"])
    if "mark_as_read" in request.POST:
        return mark_as_read(request, request.POST["mark_as_read"])
    if "unshare" in request.POST:
        return unshare(request, request.POST["unshare"])
    if "create_html_snapshot" in request.POST:
        return create_html_snapshot(request, request.POST["create_html_snapshot"])
    if "upload_asset" in request.POST:
        return upload_asset(request, request.POST["upload_asset"])
    if "remove_asset" in request.POST:
        return remove_asset(request, request.POST["remove_asset"])

    # State updates
    if "update_state" in request.POST:
        return update_state(request, request.POST["update_state"])

    # Bulk actions
    if "bulk_execute" in request.POST:
        if query is None:
            raise ValueError("Query must be provided for bulk actions")

        bulk_action = request.POST["bulk_action"]

        # Determine set of bookmarks
        if request.POST.get("bulk_select_across") == "on":
            # Query full list of bookmarks across all pages
            bookmark_ids = query.only("id").values_list("id", flat=True)
        else:
            # Use only selected bookmarks
            bookmark_ids = request.POST.getlist("bookmark_id")

        if bulk_action == "bulk_archive":
            return archive_bookmarks(bookmark_ids, request.user)
        if bulk_action == "bulk_unarchive":
            return unarchive_bookmarks(bookmark_ids, request.user)
        if bulk_action == "bulk_delete":
            return delete_bookmarks(bookmark_ids, request.user)
        if bulk_action == "bulk_tag":
            tag_string = convert_tag_string(request.POST["bulk_tag_string"])
            return tag_bookmarks(bookmark_ids, tag_string, request.user)
        if bulk_action == "bulk_untag":
            tag_string = convert_tag_string(request.POST["bulk_tag_string"])
            return untag_bookmarks(bookmark_ids, tag_string, request.user)
        if bulk_action == "bulk_read":
            return mark_bookmarks_as_read(bookmark_ids, request.user)
        if bulk_action == "bulk_unread":
            return mark_bookmarks_as_unread(bookmark_ids, request.user)
        if bulk_action == "bulk_share":
            return share_bookmarks(bookmark_ids, request.user)
        if bulk_action == "bulk_unshare":
            return unshare_bookmarks(bookmark_ids, request.user)
        if bulk_action == "bulk_refresh":
            return refresh_bookmarks_metadata(bookmark_ids, request.user)
        if bulk_action == "bulk_snapshot":
            return create_html_snapshots(bookmark_ids, request.user)


@login_required
def close(request: HttpRequest):
    return render(request, "bookmarks/close.html")


================================================
FILE: bookmarks/views/bundles.py
================================================
from django.contrib import messages
from django.contrib.auth.decorators import login_required
from django.http import HttpRequest, HttpResponseRedirect
from django.shortcuts import render
from django.urls import reverse

from bookmarks.forms import BookmarkBundleForm
from bookmarks.models import BookmarkBundle, BookmarkSearch
from bookmarks.queries import parse_query_string
from bookmarks.services import bundles
from bookmarks.views import access
from bookmarks.views.contexts import ActiveBookmarkListContext


@login_required
def index(request: HttpRequest):
    bundles = BookmarkBundle.objects.filter(owner=request.user).order_by("order")
    context = {"bundles": bundles}
    return render(request, "bundles/index.html", context)


@login_required
def action(request: HttpRequest):
    if "remove_bundle" in request.POST:
        remove_bundle_id = request.POST.get("remove_bundle")
        bundle = access.bundle_write(request, remove_bundle_id)
        bundle_name = bundle.name
        bundles.delete_bundle(bundle)
        messages.success(request, f"Bundle '{bundle_name}' removed successfully.")

    elif "move_bundle" in request.POST:
        bundle_id = request.POST.get("move_bundle")
        bundle_to_move = access.bundle_write(request, bundle_id)
        move_position = int(request.POST.get("move_position"))
        bundles.move_bundle(bundle_to_move, move_position)

    return HttpResponseRedirect(reverse("linkding:bundles.index"))


def _handle_edit(request: HttpRequest, template: str, bundle: BookmarkBundle = None):
    form_data = request.POST if request.method == "POST" else None
    initial_data = {}
    if bundle is None and request.method == "GET":
        query_param = request.GET.get("q")
        if query_param:
            parsed = parse_query_string(query_param)

            if parsed["search_terms"]:
                initial_data["search"] = " ".join(parsed["search_terms"])
            if parsed["tag_names"]:
                initial_data["all_tags"] = " ".join(parsed["tag_names"])

    form = BookmarkBundleForm(form_data, instance=bundle, initial=initial_data)

    if request.method == "POST" and form.is_valid():
        instance = form.save(commit=False)

        if bundle is None:
            instance.order = None
            bundles.create_bundle(instance, request.user)
        else:
            instance.save()

        messages.success(request, "Bundle saved successfully.")
        return HttpResponseRedirect(reverse("linkding:bundles.index"))

    status = 422 if request.method == "POST" and not form.is_valid() else 200
    bookmark_list = _get_bookmark_list_preview(request, bundle, initial_data)
    context = {
        "form": form,
        "bundle": bundle,
        "bookmark_list": bookmark_list,
    }

    return render(request, template, context, status=status)


@login_required
def new(request: HttpRequest):
    return _handle_edit(request, "bundles/new.html")


@login_required
def edit(request: HttpRequest, bundle_id: int):
    bundle = access.bundle_write(request, bundle_id)

    return _handle_edit(request, "bundles/edit.html", bundle)


@login_required
def preview(request: HttpRequest):
    bookmark_list = _get_bookmark_list_preview(request)
    context = {"bookmark_list": bookmark_list}
    return render(request, "bundles/preview.html", context)


def _get_bookmark_list_preview(
    request: HttpRequest,
    bundle: BookmarkBundle | None = None,
    initial_data: dict = None,
):
    if request.method == "GET" and bundle:
        preview_bundle = bundle
    else:
        form_data = (
            request.POST.copy() if request.method == "POST" else request.GET.copy()
        )
        if initial_data:
            for key, value in initial_data.items():
                form_data[key] = value

        form_data["name"] = "Preview Bundle"  # Set dummy name for form validation
        form = BookmarkBundleForm(form_data)
        preview_bundle = form.save(commit=False)

    search = BookmarkSearch(bundle=preview_bundle)
    bookmark_list = ActiveBookmarkListContext(request, search)
    bookmark_list.is_preview = True
    return bookmark_list


================================================
FILE: bookmarks/views/contexts.py
================================================
import re
import urllib.parse

from django.conf import settings
from django.core.paginator import Paginator
from django.db import models
from django.http import Http404
from django.urls import reverse

from bookmarks import queries, utils
from bookmarks.forms import BookmarkSearchForm
from bookmarks.models import (
    Bookmark,
    BookmarkAsset,
    BookmarkBundle,
    BookmarkSearch,
    Tag,
    User,
    UserProfile,
)
from bookmarks.services.search_query_parser import (
    OrExpression,
    SearchQueryParseError,
    parse_search_query,
    strip_tag_from_query,
)
from bookmarks.services.wayback import generate_fallback_webarchive_url
from bookmarks.type_defs import HttpRequest
from bookmarks.views import access

CJK_RE = re.compile(r"[\u4e00-\u9fff]+")


class RequestContext:
    index_view = "linkding:bookmarks.index"
    action_view = "linkding:bookmarks.index.action"

    def __init__(self, request: HttpRequest):
        self.request = request
        self.index_url = reverse(self.index_view)
        self.action_url = reverse(self.action_view)
        self.query_params = request.GET.copy()
        self.query_params.pop("details", None)

        self.query_is_valid = True
        self.query_error_message = None
        self.search_expression = None
        if not request.user_profile.legacy_search:
            try:
                self.search_expression = parse_search_query(request.GET.get("q"))
            except SearchQueryParseError as e:
                self.query_is_valid = False
                self.query_error_message = e.message

    def get_url(self, view_url: str, add: dict = None, remove: dict = None) -> str:
        query_params = self.query_params.copy()
        if add:
            query_params.update(add)
        if remove:
            for key in remove:
                query_params.pop(key, None)
        encoded_params = query_params.urlencode()
        return view_url + "?" + encoded_params if encoded_params else view_url

    def index(self, add: dict = None, remove: dict = None) -> str:
        return self.get_url(self.index_url, add=add, remove=remove)

    def action(self, add: dict = None, remove: dict = None) -> str:
        return self.get_url(self.action_url, add=add, remove=remove)

    def details(self, bookmark_id: int) -> str:
        return self.get_url(self.index_url, add={"details": bookmark_id})

    def get_bookmark_query_set(self, search: BookmarkSearch):
        raise NotImplementedError("Must be implemented by subclass")

    def get_tag_query_set(self, search: BookmarkSearch):
        raise NotImplementedError("Must be implemented by subclass")


class ActiveBookmarksContext(RequestContext):
    index_view = "linkding:bookmarks.index"
    action_view = "linkding:bookmarks.index.action"

    def get_bookmark_query_set(self, search: BookmarkSearch):
        return queries.query_bookmarks(
            self.request.user, self.request.user_profile, search
        )

    def get_tag_query_set(self, search: BookmarkSearch):
        return queries.query_bookmark_tags(
            self.request.user, self.request.user_profile, search
        )


class ArchivedBookmarksContext(RequestContext):
    index_view = "linkding:bookmarks.archived"
    action_view = "linkding:bookmarks.archived.action"

    def get_bookmark_query_set(self, search: BookmarkSearch):
        return queries.query_archived_bookmarks(
            self.request.user, self.request.user_profile, search
        )

    def get_tag_query_set(self, search: BookmarkSearch):
        return queries.query_archived_bookmark_tags(
            self.request.user, self.request.user_profile, search
        )


class SharedBookmarksContext(RequestContext):
    index_view = "linkding:bookmarks.shared"
    action_view = "linkding:bookmarks.shared.action"

    def get_bookmark_query_set(self, search: BookmarkSearch):
        user = User.objects.filter(username=search.user).first()
        public_only = not self.request.user.is_authenticated
        return queries.query_shared_bookmarks(
            user, self.request.user_profile, search, public_only
        )

    def get_tag_query_set(self, search: BookmarkSearch):
        user = User.objects.filter(username=search.user).first()
        public_only = not self.request.user.is_authenticated
        return queries.query_shared_bookmark_tags(
            user, self.request.user_profile, search, public_only
        )


class BookmarkItem:
    def __init__(
        self,
        context: RequestContext,
        bookmark: Bookmark,
        user: User,
        profile: UserProfile,
    ) -> None:
        self.bookmark = bookmark

        is_editable = bookmark.owner == user
        self.is_editable = is_editable

        self.id = bookmark.id
        self.url = bookmark.url
        self.title = bookmark.resolved_title
        self.description = bookmark.resolved_description
        self.notes = bookmark.notes
        self.tag_names = bookmark.tag_names
        self.tags = [AddTagItem(context, tag) for tag in bookmark.tags.all()]
        self.tags.sort(key=lambda item: item.name)
        if bookmark.latest_snapshot_id:
            self.snapshot_url = reverse(
                "linkding:assets.view", args=[bookmark.latest_snapshot_id]
            )
            self.snapshot_title = "View latest snapshot"
        else:
            self.snapshot_url = bookmark.web_archive_snapshot_url
            self.snapshot_title = (
                "View snapshot on the Internet Archive Wayback Machine"
            )
            if not self.snapshot_url:
                self.snapshot_url = generate_fallback_webarchive_url(
                    bookmark.url, bookmark.date_added
                )
        self.favicon_file = bookmark.favicon_file
        self.preview_image_file = bookmark.preview_image_file
        self.is_archived = bookmark.is_archived
        self.unread = bookmark.unread
        self.owner = bookmark.owner
        self.details_url = context.details(bookmark.id)

        css_classes = []
        if bookmark.unread:
            css_classes.append("unread")
        if bookmark.shared:
            css_classes.append("shared")

        self.css_classes = " ".join(css_classes)

        if profile.bookmark_date_display == UserProfile.BOOKMARK_DATE_DISPLAY_RELATIVE:
            self.display_date = utils.humanize_relative_date(bookmark.date_added)
        elif (
            profile.bookmark_date_display == UserProfile.BOOKMARK_DATE_DISPLAY_ABSOLUTE
        ):
            self.display_date = utils.humanize_absolute_date(bookmark.date_added)

        self.show_notes_button = bookmark.notes and not profile.permanent_notes
        self.show_mark_as_read = is_editable and bookmark.unread
        self.show_unshare = is_editable and bookmark.shared and profile.enable_sharing

        self.has_extra_actions = (
            self.show_notes_button or self.show_mark_as_read or self.show_unshare
        )


class BookmarkListContext:
    request_context = RequestContext

    def __init__(self, request: HttpRequest, search: BookmarkSearch) -> None:
        request_context = self.request_context(request)
        user = request.user
        user_profile = request.user_profile

        self.request = request
        self.search = search
        self.query_is_valid = request_context.query_is_valid
        self.query_error_message = request_context.query_error_message

        query_set = request_context.get_bookmark_query_set(self.search)
        page_number = request.GET.get("page")
        paginator = Paginator(query_set, user_profile.items_per_page)
        bookmarks_page = paginator.get_page(page_number)
        # Prefetch related objects, this avoids n+1 queries when accessing fields in templates
        models.prefetch_related_objects(bookmarks_page.object_list, "owner", "tags")

        self.items = [
            BookmarkItem(request_context, bookmark, user, user_profile)
            for bookmark in bookmarks_page
        ]
        self.is_empty = paginator.count == 0
        self.bookmarks_page = bookmarks_page
        self.bookmarks_total = paginator.count

        self.return_url = request_context.index()
        self.action_url = request_context.action()

        self.link_target = user_profile.bookmark_link_target
        self.date_display = user_profile.bookmark_date_display
        self.description_display = user_profile.bookmark_description_display
        self.description_max_lines = user_profile.bookmark_description_max_lines
        self.show_url = user_profile.display_url
        self.show_view_action = user_profile.display_view_bookmark_action
        self.show_edit_action = user_profile.display_edit_bookmark_action
        self.show_archive_action = user_profile.display_archive_bookmark_action
        self.show_remove_action = user_profile.display_remove_bookmark_action
        self.show_favicons = user_profile.enable_favicons
        self.show_preview_images = user_profile.enable_preview_images
        self.show_notes = user_profile.permanent_notes
        self.collapse_side_panel = user_profile.collapse_side_panel
        self.is_preview = False
        self.snapshot_feature_enabled = settings.LD_ENABLE_SNAPSHOTS

    @staticmethod
    def generate_return_url(search: BookmarkSearch, base_url: str, page: int = None):
        query_params = search.query_params
        if page is not None:
            query_params["page"] = page
        query_string = urllib.parse.urlencode(query_params)

        return base_url if query_string == "" else base_url + "?" + query_string

    @staticmethod
    def generate_action_url(
        search: BookmarkSearch, base_action_url: str, return_url: str
    ):
        query_params = search.query_params
        query_params["return_url"] = return_url
        query_string = urllib.parse.urlencode(query_params)

        return (
            base_action_url
            if query_string == ""
            else base_action_url + "?" + query_string
        )


class ActiveBookmarkListContext(BookmarkListContext):
    list_title = "Bookmarks"
    search_mode = ""
    bulk_edit_enabled = True
    bulk_edit_disabled_actions = "bulk_unarchive"
    request_context = ActiveBookmarksContext


class ArchivedBookmarkListContext(BookmarkListContext):
    list_title = "Archived bookmarks"
    search_mode = "archived"
    bulk_edit_enabled = True
    bulk_edit_disabled_actions = "bulk_archive"
    request_context = ArchivedBookmarksContext


class SharedBookmarkListContext(BookmarkListContext):
    list_title = "Shared bookmarks"
    search_mode = "shared"
    bulk_edit_enabled = False
    bulk_edit_disabled_actions = ""
    request_context = SharedBookmarksContext


class AddTagItem:
    def __init__(self, context: RequestContext, tag: Tag):
        self.tag = tag
        self.name = tag.name

        params = context.query_params.copy()
        query_with_tag = params.get("q", "")
        if isinstance(context.search_expression, OrExpression):
            # If the current search expression is an OR expression, wrap in parentheses
            query_with_tag = f"({query_with_tag})"
        query_with_tag = f"{query_with_tag} #{tag.name}".strip()

        params["q"] = query_with_tag
        params.pop("details", None)
        params.pop("page", None)

        if context.request.user_profile.legacy_search:
            self.query_string = self._generate_query_string_legacy(context, tag)
        else:
            self.query_string = self._generate_query_string(context, tag)

    @staticmethod
    def _generate_query_string(context: RequestContext, tag: Tag) -> str:
        params = context.query_params.copy()
        query_with_tag = params.get("q", "")
        if isinstance(context.search_expression, OrExpression):
            # If the current search expression is an OR expression, wrap in parentheses
            query_with_tag = f"({query_with_tag})"
        query_with_tag = f"{query_with_tag} #{tag.name}".strip()

        params["q"] = query_with_tag
        params.pop("details", None)
        params.pop("page", None)

        return params.urlencode()

    @staticmethod
    def _generate_query_string_legacy(context: RequestContext, tag: Tag) -> str:
        params = context.query_params.copy()
        query_with_tag = params.get("q", "")
        query_with_tag = f"{query_with_tag} #{tag.name}".strip()

        params["q"] = query_with_tag
        params.pop("details", None)
        params.pop("page", None)

        return params.urlencode()


class RemoveTagItem:
    def __init__(self, context: RequestContext, tag: Tag):
        self.tag = tag
        self.name = tag.name

        if context.request.user_profile.legacy_search:
            self.query_string = self._generate_query_string_legacy(context, tag)
        else:
            self.query_string = self._generate_query_string(context, tag)

    @staticmethod
    def _generate_query_string(context: RequestContext, tag: Tag) -> str:
        params = context.query_params.copy()
        query = params.get("q", "")
        profile = context.request.user_profile
        query_without_tag = strip_tag_from_query(query, tag.name, profile)

        params["q"] = query_without_tag
        params.pop("details", None)
        params.pop("page", None)

        return params.urlencode()

    @staticmethod
    def _generate_query_string_legacy(context: RequestContext, tag: Tag) -> 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)

        # Remove details ID and page number
        params.pop("details", None)
        params.pop("page", None)

        return params.urlencode()


class TagGroup:
    def __init__(
        self, context: RequestContext, char: str, highlight_first_char: bool = True
    ):
        self.context = context
        self.tags = []
        self.char = char
        self.highlight_first_char = highlight_first_char

    def __repr__(self):
        return f"<{self.char} TagGroup>"

    def add_tag(self, tag: Tag):
        self.tags.append(AddTagItem(self.context, tag))

    @staticmethod
    def create_tag_groups(context: RequestContext, mode: str, tags: set[Tag]):
        if mode == UserProfile.TAG_GROUPING_ALPHABETICAL:
            return TagGroup._create_tag_groups_alphabetical(context, tags)
        elif mode == UserProfile.TAG_GROUPING_DISABLED:
            return TagGroup._create_tag_groups_disabled(context, tags)
        else:
            raise ValueError(f"{mode} is not a valid tag grouping mode")

    @staticmethod
    def _create_tag_groups_alphabetical(context: RequestContext, 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 = []

        cjk_used = False
        cjk_group = TagGroup(context, "Ideographic")

        # Group tags that start with a different character than the previous one
        for tag in sorted_tags:
            tag_char = tag.name[0].lower()
            if CJK_RE.match(tag_char):
                cjk_used = True
                cjk_group.add_tag(tag)
            elif not group or group.char != tag_char:
                group = TagGroup(context, tag_char)
                groups.append(group)
                group.add_tag(tag)
            else:
                group.add_tag(tag)

        if cjk_used:
            groups.append(cjk_group)
        return groups

    @staticmethod
    def _create_tag_groups_disabled(context: RequestContext, tags: set[Tag]):
        if len(tags) == 0:
            return []

        sorted_tags = sorted(tags, key=lambda x: str.lower(x.name))
        group = TagGroup(context, "Ungrouped", highlight_first_char=False)
        for tag in sorted_tags:
            group.add_tag(tag)

        return [group]


class TagCloudContext:
    request_context = RequestContext

    def __init__(self, request: HttpRequest, search: BookmarkSearch) -> None:
        request_context = self.request_context(request)
        user_profile = request.user_profile

        self.request = request
        self.search = search

        query_set = request_context.get_tag_query_set(self.search)
        tags = list(query_set)
        selected_tags = self.get_selected_tags()
        unique_tags = utils.unique(tags, key=lambda x: str.lower(x.name))
        unique_selected_tags = utils.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 = TagGroup.create_tag_groups(
            request_context, user_profile.tag_grouping, unselected_tags
        )

        selected_tag_items = []
        for tag in unique_selected_tags:
            selected_tag_items.append(RemoveTagItem(request_context, tag))

        self.tags = unique_tags
        self.groups = groups
        self.selected_tags = selected_tag_items
        self.has_selected_tags = has_selected_tags

    def get_selected_tags(self):
        raise NotImplementedError("Must be implemented by subclass")

    def get_selected_tags_legacy(self, tags: list[Tag]):
        parsed_query = queries.parse_query_string(self.search.q)
        tag_names = parsed_query["tag_names"]
        if self.request.user_profile.tag_search == UserProfile.TAG_SEARCH_LAX:
            tag_names = tag_names + parsed_query["search_terms"]
        tag_names = [tag_name.lower() for tag_name in tag_names]

        return [tag for tag in tags if tag.name.lower() in tag_names]


class ActiveTagCloudContext(TagCloudContext):
    request_context = ActiveBookmarksContext

    def get_selected_tags(self):
        return list(
            queries.get_tags_for_query(
                self.request.user, self.request.user_profile, self.search.q
            )
        )


class ArchivedTagCloudContext(TagCloudContext):
    request_context = ArchivedBookmarksContext

    def get_selected_tags(self):
        return list(
            queries.get_tags_for_query(
                self.request.user, self.request.user_profile, self.search.q
            )
        )


class SharedTagCloudContext(TagCloudContext):
    request_context = SharedBookmarksContext

    def get_selected_tags(self):
        user = User.objects.filter(username=self.search.user).first()
        public_only = not self.request.user.is_authenticated
        return list(
            queries.get_shared_tags_for_query(
                user, self.request.user_profile, self.search.q, public_only
            )
        )


class BookmarkAssetItem:
    def __init__(self, asset: BookmarkAsset):
        self.asset = asset

        self.id = asset.id
        self.display_name = asset.display_name
        self.asset_type = asset.asset_type
        self.file = asset.file
        self.file_size = asset.file_size
        self.content_type = asset.content_type
        self.status = asset.status

        icon_classes = []
        text_classes = []
        if asset.status == BookmarkAsset.STATUS_PENDING:
            icon_classes.append("text-tertiary")
            text_classes.append("text-tertiary")
        elif asset.status == BookmarkAsset.STATUS_FAILURE:
            icon_classes.append("text-error")
            text_classes.append("text-error")
        else:
            icon_classes.append("icon-color")

        self.icon_classes = " ".join(icon_classes)
        self.text_classes = " ".join(text_classes)


class BookmarkDetailsContext:
    request_context = RequestContext

    def __init__(self, request: HttpRequest, bookmark: Bookmark):
        request_context = self.request_context(request)

        user = request.user
        user_profile = request.user_profile

        self.edit_return_url = request_context.details(bookmark.id)
        self.action_url = request_context.action(add={"details": bookmark.id})
        self.delete_url = request_context.action()
        self.close_url = request_context.index()

        self.bookmark = bookmark
        self.tags = [AddTagItem(request_context, tag) for tag in bookmark.tags.all()]
        self.tags.sort(key=lambda item: item.name)

        self.profile = request.user_profile
        self.is_editable = bookmark.owner == user
        self.sharing_enabled = user_profile.enable_sharing
        self.preview_image_enabled = user_profile.enable_preview_images
        self.show_link_icons = user_profile.enable_favicons and bookmark.favicon_file
        self.snapshots_enabled = settings.LD_ENABLE_SNAPSHOTS
        self.uploads_enabled = not settings.LD_DISABLE_ASSET_UPLOAD

        self.web_archive_snapshot_url = bookmark.web_archive_snapshot_url
        if not self.web_archive_snapshot_url:
            self.web_archive_snapshot_url = generate_fallback_webarchive_url(
                bookmark.url, bookmark.date_added
            )

        self.assets = [
            BookmarkAssetItem(asset) for asset in bookmark.bookmarkasset_set.all()
        ]
        self.has_pending_assets = any(
            asset.status == BookmarkAsset.STATUS_PENDING for asset in self.assets
        )
        self.latest_snapshot = next(
            (
                asset
                for asset in self.assets
                if asset.asset.asset_type == BookmarkAsset.TYPE_SNAPSHOT
                and asset.status == BookmarkAsset.STATUS_COMPLETE
            ),
            None,
        )


class ActiveBookmarkDetailsContext(BookmarkDetailsContext):
    request_context = ActiveBookmarksContext


class ArchivedBookmarkDetailsContext(BookmarkDetailsContext):
    request_context = ArchivedBookmarksContext


class SharedBookmarkDetailsContext(BookmarkDetailsContext):
    request_context = SharedBookmarksContext


def get_details_context(
    request: HttpRequest, context_type
) -> BookmarkDetailsContext | None:
    bookmark_id = request.GET.get("details")
    if not bookmark_id:
        return None

    try:
        bookmark = access.bookmark_read(request, bookmark_id)
    except Http404:
        # just ignore, might end up in a situation where the bookmark was deleted
        # in between navigating back and forth
        return None

    return context_type(request, bookmark)


class BundlesContext:
    def __init__(self, request: HttpRequest) -> None:
        self.request = request
        self.user = request.user
        self.user_profile = request.user_profile

        self.bundles = (
            BookmarkBundle.objects.filter(owner=self.user).order_by("order").all()
        )
        self.is_empty = len(self.bundles) == 0

        selected_bundle_id = (
            int(request.GET.get("bundle")) if request.GET.get("bundle") else None
        )
        self.selected_bundle = next(
            (bundle for bundle in self.bundles if bundle.id == selected_bundle_id),
            None,
        )


class UserListContext:
    def __init__(self, request: HttpRequest, search: BookmarkSearch) -> None:
        public_only = not request.user.is_authenticated
        users = queries.query_shared_bookmark_users(
            request.user_profile, search, public_only
        )
        users = sorted(users, key=lambda x: str.lower(x.username))
        self.form = BookmarkSearchForm(search, editable_fields=["user"], users=users)


================================================
FILE: bookmarks/views/custom_css.py
================================================
from django.http import HttpResponse

custom_css_cache_max_age = 2592000  # 30 days


def custom_css(request):
    css = request.user_profile.custom_css
    response = HttpResponse(css, content_type="text/css")
    response["Cache-Control"] = f"public, max-age={custom_css_cache_max_age}"
    return response


================================================
FILE: bookmarks/views/health.py
================================================
from django.db import connections
from django.http import JsonResponse

from bookmarks.views.settings import app_version


def health(request):
    code = 200
    response = {"version": app_version, "status": "healthy"}

    try:
        connections["default"].ensure_connection()
    except Exception:
        response["status"] = "unhealthy"
        code = 500

    return JsonResponse(response, status=code)


================================================
FILE: bookmarks/views/manifest.py
================================================
from django.conf import settings
from django.http import JsonResponse


def manifest(request):
    response = {
        "short_name": "linkding",
        "name": "linkding",
        "description": "Self-hosted bookmark service",
        "start_url": "bookmarks",
        "display": "standalone",
        "scope": "/" + settings.LD_CONTEXT_PATH,
        "theme_color": "#5856e0",
        "background_color": (
            "#161822" if request.user_profile.theme == "dark" else "#ffffff"
        ),
        "icons": [
            {
                "src": "/" + settings.LD_CONTEXT_PATH + "static/logo.svg",
                "type": "image/svg+xml",
                "sizes": "512x512",
                "purpose": "any",
            },
            {
                "src": "/" + settings.LD_CONTEXT_PATH + "static/logo-512.png",
                "type": "image/png",
                "sizes": "512x512",
                "purpose": "any",
            },
            {
                "src": "/" + settings.LD_CONTEXT_PATH + "static/logo-192.png",
                "type": "image/png",
                "sizes": "192x192",
                "purpose": "any",
            },
            {
                "src": "/" + settings.LD_CONTEXT_PATH + "static/maskable-logo.svg",
                "type": "image/svg+xml",
                "sizes": "512x512",
                "purpose": "maskable",
            },
            {
                "src": "/" + settings.LD_CONTEXT_PATH + "static/maskable-logo-512.png",
                "type": "image/png",
                "sizes": "512x512",
                "purpose": "maskable",
            },
            {
                "src": "/" + settings.LD_CONTEXT_PATH + "static/maskable-logo-192.png",
                "type": "image/png",
                "sizes": "192x192",
                "purpose": "maskable",
            },
        ],
        "shortcuts": [
            {
                "name": "Add bookmark",
                "url": "/" + settings.LD_CONTEXT_PATH + "bookmarks/new",
            },
            {
                "name": "Archived",
                "url": "/" + settings.LD_CONTEXT_PATH + "bookmarks/archived",
            },
            {
                "name": "Unread",
                "url": "/" + settings.LD_CONTEXT_PATH + "bookmarks?unread=yes",
            },
            {
                "name": "Untagged",
                "url": "/" + settings.LD_CONTEXT_PATH + "bookmarks?q=!untagged",
            },
            {
                "name": "Shared",
                "url": "/" + settings.LD_CONTEXT_PATH + "bookmarks/shared",
            },
        ],
        "screenshots": [
            {
                "src": "/"
                + settings.LD_CONTEXT_PATH
                + "static/linkding-screenshot.png",
                "type": "image/png",
                "sizes": "2158x1160",
                "form_factor": "wide",
            }
        ],
        "share_target": {
            "action": "/" + settings.LD_CONTEXT_PATH + "bookmarks/new",
            "method": "GET",
            "enctype": "application/x-www-form-urlencoded",
            "params": {
                "url": "url",
                "text": "url",
                "title": "title",
            },
        },
    }

    return JsonResponse(response, status=200)


================================================
FILE: bookmarks/views/opensearch.py
================================================
from django.shortcuts import render
from django.urls import reverse


def opensearch(request):
    base_url = request.build_absolute_uri(reverse("linkding:root"))
    bookmarks_url = request.build_absolute_uri(reverse("linkding:bookmarks.index"))

    return render(
        request,
        "opensearch.xml",
        {
            "base_url": base_url,
            "bookmarks_url": bookmarks_url,
        },
        content_type="application/opensearchdescription+xml",
        status=200,
    )


================================================
FILE: bookmarks/views/reload.py
================================================
import json
import threading
import uuid
from pathlib import Path
from queue import Empty, Queue

from django.dispatch import receiver
from django.http import StreamingHttpResponse
from django.utils.autoreload import autoreload_started, file_changed

_styles_dir = Path(__file__).resolve().parent.parent / "styles"
_static_dir = Path(__file__).resolve().parent.parent / "static"

_server_id = str(uuid.uuid4())

_active_connections = set()
_connections_lock = threading.Lock()


def _event_stream():
    client_queue = Queue()

    with _connections_lock:
        _active_connections.add(client_queue)

    try:
        data = json.dumps({"server_id": _server_id})
        yield f"event: connected\ndata: {data}\n\n"

        while True:
            try:
                data = client_queue.get(timeout=30)
                yield f"event: file_change\ndata: {data}\n\n"
            except Empty:
                yield ": keepalive\n\n"
    finally:
        with _connections_lock:
            _active_connections.discard(client_queue)


def live_reload(request):
    response = StreamingHttpResponse(_event_stream(), content_type="text/event-stream")
    response["Cache-Control"] = "no-cache"
    return response


@receiver(autoreload_started)
def handle_auto_reload(sender, **kwargs):
    sender.watch_dir(_styles_dir, "**/*.css")
    sender.watch_dir(_static_dir, "bundle.js")


@receiver(file_changed)
def handle_file_changed(sender, file_path, **kwargs):
    print(f"File changed: {file_path}")
    data = json.dumps({"file_path": str(file_path)})
    with _connections_lock:
        for queue in _active_connections:
            queue.put(data)

    # Return True for CSS/JS files to prevent Django server restart
    if file_path.suffix in (".css", ".js"):
        return True


================================================
FILE: bookmarks/views/root.py
================================================
from django.http import HttpResponseRedirect
from django.urls import reverse

from bookmarks.models import GlobalSettings


def root(request):
    # Redirect unauthenticated users to the configured landing page
    if not request.user.is_authenticated:
        settings = request.global_settings

        if settings.landing_page == GlobalSettings.LANDING_PAGE_SHARED_BOOKMARKS:
            return HttpResponseRedirect(reverse("linkding:bookmarks.shared"))
        else:
            return HttpResponseRedirect(reverse("login"))

    # Redirect authenticated users to the bookmarks page
    return HttpResponseRedirect(reverse("linkding:bookmarks.index"))


================================================
FILE: bookmarks/views/settings.py
================================================
import logging
import time
from functools import lru_cache

import requests
from django.conf import settings as django_settings
from django.contrib import messages
from django.contrib.auth.decorators import login_required
from django.core.exceptions import PermissionDenied
from django.db.models import prefetch_related_objects
from django.http import HttpResponse, HttpResponseRedirect
from django.shortcuts import render
from django.urls import reverse
from django.utils import timezone

from bookmarks.forms import GlobalSettingsForm, UserProfileForm
from bookmarks.models import (
    ApiToken,
    Bookmark,
    FeedToken,
    GlobalSettings,
)
from bookmarks.services import exporter, importer, tasks
from bookmarks.type_defs import HttpRequest
from bookmarks.utils import app_version
from bookmarks.views import access

logger = logging.getLogger(__name__)


@login_required
def general(request: HttpRequest, status=200, context_overrides=None):
    enable_refresh_favicons = django_settings.LD_ENABLE_REFRESH_FAVICONS
    has_snapshot_support = django_settings.LD_ENABLE_SNAPSHOTS
    success_message = _find_message_with_tag(
        messages.get_messages(request), "settings_success_message"
    )
    error_message = _find_message_with_tag(
        messages.get_messages(request), "settings_error_message"
    )
    version_info = get_version_info(get_ttl_hash())

    profile_form = UserProfileForm(instance=request.user_profile)
    global_settings_form = None
    if request.user.is_superuser:
        global_settings_form = GlobalSettingsForm(instance=GlobalSettings.get())

    if context_overrides is None:
        context_overrides = {}

    return render(
        request,
        "settings/general.html",
        {
            "form": profile_form,
            "global_settings_form": global_settings_form,
            "enable_refresh_favicons": enable_refresh_favicons,
            "has_snapshot_support": has_snapshot_support,
            "success_message": success_message,
            "error_message": error_message,
            "version_info": version_info,
            **context_overrides,
        },
        status=status,
    )


@login_required
def update(request: HttpRequest):
    if request.method == "POST":
        if "update_profile" in request.POST:
            return update_profile(request)
        if "update_global_settings" in request.POST:
            update_global_settings(request)
            messages.success(
                request, "Global settings updated", "settings_success_message"
            )
        if "refresh_favicons" in request.POST:
            tasks.schedule_refresh_favicons(request.user)
            messages.success(
                request,
                "Scheduled favicon update. This may take a while...",
                "settings_success_message",
            )
        if "create_missing_html_snapshots" in request.POST:
            count = tasks.create_missing_html_snapshots(request.user)
            if count > 0:
                messages.success(
                    request,
                    f"Queued {count} missing snapshots. This may take a while...",
                    "settings_success_message",
                )
            else:
                messages.success(
                    request, "No missing snapshots found.", "settings_success_message"
                )

    return HttpResponseRedirect(reverse("linkding:settings.general"))


def update_profile(request: HttpRequest):
    user = request.user
    profile = user.profile
    favicons_were_enabled = profile.enable_favicons
    previews_were_enabled = profile.enable_preview_images
    form = UserProfileForm(request.POST, instance=profile)
    if form.is_valid():
        form.save()
        messages.success(request, "Profile updated", "settings_success_message")
        # Load missing favicons if the feature was just enabled
        if profile.enable_favicons and not favicons_were_enabled:
            tasks.schedule_bookmarks_without_favicons(request.user)
        # Load missing preview images if the feature was just enabled
        if profile.enable_preview_images and not previews_were_enabled:
            tasks.schedule_bookmarks_without_previews(request.user)

        return HttpResponseRedirect(reverse("linkding:settings.general"))

    messages.error(
        request,
        "Profile update failed, check the form below for errors",
        "settings_error_message",
    )
    return general(request, 422, {"form": form})


def update_global_settings(request):
    user = request.user
    if not user.is_superuser:
        raise PermissionDenied()

    form = GlobalSettingsForm(request.POST, instance=GlobalSettings.get())
    if form.is_valid():
        form.save()
    return form


# Cache API call response, for one hour when using get_ttl_hash with default params
@lru_cache(maxsize=1)
def get_version_info(ttl_hash=None):
    latest_version = None
    try:
        latest_version_url = (
            "https://api.github.com/repos/sissbruecker/linkding/releases/latest"
        )
        response = requests.get(latest_version_url, timeout=5)
        json = response.json()
        if response.status_code == 200 and "name" in json:
            latest_version = json["name"][1:]
    except requests.exceptions.RequestException:
        pass

    latest_version_info = ""
    if latest_version == app_version:
        latest_version_info = " (latest)"
    elif latest_version is not None:
        latest_version_info = f" (latest: {latest_version})"

    return f"{app_version}{latest_version_info}"


def get_ttl_hash(seconds=3600):
    """Return the same value within `seconds` time period"""
    return round(time.time() / seconds)


@login_required
def integrations(request):
    application_url = request.build_absolute_uri(reverse("linkding:bookmarks.new"))

    api_tokens = ApiToken.objects.filter(user=request.user).order_by("-created")
    api_token_key = request.session.pop("api_token_key", None)
    api_token_name = request.session.pop("api_token_name", None)
    api_success_message = _find_message_with_tag(
        messages.get_messages(request), "api_success_message"
    )

    feed_token = FeedToken.objects.get_or_create(user=request.user)[0]

    all_feed_url = reverse("linkding:feeds.all", args=[feed_token.key])
    unread_feed_url = reverse("linkding:feeds.unread", args=[feed_token.key])
    shared_feed_url = reverse("linkding:feeds.shared", args=[feed_token.key])
    public_shared_feed_url = reverse("linkding:feeds.public_shared")

    return render(
        request,
        "settings/integrations.html",
        {
            "application_url": application_url,
            "api_tokens": api_tokens,
            "api_token_key": api_token_key,
            "api_token_name": api_token_name,
            "api_success_message": api_success_message,
            "all_feed_url": all_feed_url,
            "unread_feed_url": unread_feed_url,
            "shared_feed_url": shared_feed_url,
            "public_shared_feed_url": public_shared_feed_url,
        },
    )


@login_required
def create_api_token(request):
    if request.method == "POST":
        name = request.POST.get("name", "").strip()
        if not name:
            name = "API Token"

        token = ApiToken(user=request.user, name=name)
        token.save()

        request.session["api_token_key"] = token.key
        request.session["api_token_name"] = token.name

        messages.success(
            request,
            f'API token "{token.name}" created successfully',
            "api_success_message",
        )

        return HttpResponseRedirect(reverse("linkding:settings.integrations"))

    return render(request, "settings/create_api_token_modal.html")


@login_required
def delete_api_token(request):
    if request.method == "POST":
        token_id = request.POST.get("token_id")
        token = access.api_token_write(request, token_id)
        token_name = token.name
        token.delete()
        messages.success(
            request,
            f'API token "{token_name}" has been deleted.',
            "api_success_message",
        )

    return HttpResponseRedirect(reverse("linkding:settings.integrations"))


@login_required
def bookmark_import(request: HttpRequest):
    import_file = request.FILES.get("import_file")
    import_options = importer.ImportOptions(
        map_private_flag=request.POST.get("map_private_flag") == "on"
    )

    if import_file is None:
        messages.error(
            request, "Please select a file to import.", "settings_error_message"
        )
        return HttpResponseRedirect(reverse("linkding:settings.general"))

    try:
        content = import_file.read().decode()
        result = importer.import_netscape_html(content, request.user, import_options)
        success_msg = str(result.success) + " bookmarks were successfully imported."
        messages.success(request, success_msg, "settings_success_message")
        if result.failed > 0:
            err_msg = (
                str(result.failed)
                + " bookmarks could not be imported. Please check the logs for more details."
            )
            messages.error(request, err_msg, "settings_error_message")
    except Exception:
        logging.exception("Unexpected error during bookmark import")
        messages.error(
            request,
            "An error occurred during bookmark import.",
            "settings_error_message",
        )

    return HttpResponseRedirect(reverse("linkding:settings.general"))


@login_required
def bookmark_export(request: HttpRequest):
    # noinspection PyBroadException
    try:
        bookmarks = Bookmark.objects.filter(owner=request.user)
        # Prefetch tags to prevent n+1 queries
        prefetch_related_objects(bookmarks, "tags")
        file_content = exporter.export_netscape_html(list(bookmarks))

        # Generate filename with current date and time
        current_time = timezone.now()
        filename = current_time.strftime("bookmarks_%Y-%m-%d_%H-%M-%S.html")

        response = HttpResponse(content_type="text/plain; charset=UTF-8")
        response["Content-Disposition"] = f'attachment; filename="{filename}"'
        response.write(file_content)

        return response
    except Exception:
        return general(
            request,
            context_overrides={
                "export_error": "An error occurred during bookmark export."
            },
        )


def _find_message_with_tag(messages, tag):
    for message in messages:
        if message.extra_tags == tag:
            return message


================================================
FILE: bookmarks/views/tags.py
================================================
from django.contrib import messages
from django.contrib.auth.decorators import login_required
from django.core.paginator import Paginator
from django.db import transaction
from django.db.models import Count
from django.http import HttpResponseRedirect
from django.shortcuts import get_object_or_404, render
from django.urls import reverse

from bookmarks.forms import TagForm, TagMergeForm
from bookmarks.models import Bookmark, Tag
from bookmarks.type_defs import HttpRequest
from bookmarks.utils import redirect_with_query
from bookmarks.views import turbo


@login_required
def tags_index(request: HttpRequest):
    if request.method == "POST" and "delete_tag" in request.POST:
        tag_id = request.POST.get("delete_tag")
        tag = get_object_or_404(Tag, id=tag_id, owner=request.user)
        tag.delete()
        return redirect_with_query(request, reverse("linkding:tags.index"))

    search = request.GET.get("search", "").strip()
    unused_only = request.GET.get("unused", "") == "true"
    sort = request.GET.get("sort", "name-asc")

    tags_queryset = Tag.objects.filter(owner=request.user).annotate(
        bookmark_count=Count("bookmark")
    )

    if sort == "name-desc":
        tags_queryset = tags_queryset.order_by("-name")
    elif sort == "count-asc":
        tags_queryset = tags_queryset.order_by("bookmark_count", "name")
    elif sort == "count-desc":
        tags_queryset = tags_queryset.order_by("-bookmark_count", "name")
    else:  # Default: name-asc
        tags_queryset = tags_queryset.order_by("name")
    total_tags = tags_queryset.count()

    if search:
        tags_queryset = tags_queryset.filter(name__icontains=search)

    if unused_only:
        tags_queryset = tags_queryset.filter(bookmark_count=0)

    paginator = Paginator(tags_queryset, 50)
    page_number = request.GET.get("page")
    page = paginator.get_page(page_number)

    context = {
        "page": page,
        "search": search,
        "unused_only": unused_only,
        "sort": sort,
        "total_tags": total_tags,
    }

    return render(request, "tags/index.html", context)


@login_required
def tag_new(request: HttpRequest):
    form_data = request.POST if request.method == "POST" else None
    form = TagForm(user=request.user, data=form_data)

    if request.method == "POST":
        if form.is_valid():
            tag = form.save()
            messages.success(request, f'Tag "{tag.name}" created successfully.')
            return HttpResponseRedirect(reverse("linkding:tags.index"))
        else:
            return turbo.stream(
                turbo.replace(
                    request,
                    "tag-modal",
                    "tags/new.html",
                    {"form": form},
                    method="morph",
                )
            )

    return render(request, "tags/new.html", {"form": form})


@login_required
def tag_edit(request: HttpRequest, tag_id: int):
    tag = get_object_or_404(Tag, id=tag_id, owner=request.user)
    form_data = request.POST if request.method == "POST" else None
    form = TagForm(user=request.user, data=form_data, instance=tag)

    if request.method == "POST":
        if form.is_valid():
            form.save()
            return redirect_with_query(request, reverse("linkding:tags.index"))
        else:
            return turbo.stream(
                turbo.replace(
                    request,
                    "tag-modal",
                    "tags/edit.html",
                    {"tag": tag, "form": form},
                    method="morph",
                )
            )

    return render(request, "tags/edit.html", {"tag": tag, "form": form})


@login_required
def tag_merge(request: HttpRequest):
    form_data = request.POST if request.method == "POST" else None
    form = TagMergeForm(user=request.user, data=form_data)

    if request.method == "POST":
        if form.is_valid():
            target_tag = form.cleaned_data["target_tag"]
            merge_tags = form.cleaned_data["merge_tags"]

            with transaction.atomic():
                BookmarkTag = Bookmark.tags.through

                # Get all bookmarks that have any of the merge tags, but do not
                # already have the target tag
                bookmark_ids = list(
                    Bookmark.objects.filter(tags__in=merge_tags)
                    .exclude(tags=target_tag)
                    .values_list("id", flat=True)
                    .distinct()
                )

                # Create new relationships to the target tag
                new_relationships = [
                    BookmarkTag(tag_id=target_tag.id, bookmark_id=bookmark_id)
                    for bookmark_id in bookmark_ids
                ]

                if new_relationships:
                    BookmarkTag.objects.bulk_create(new_relationships)

                # Bulk delete all relationships for merge tags
                merge_tag_ids = [tag.id for tag in merge_tags]
                BookmarkTag.objects.filter(tag_id__in=merge_tag_ids).delete()

                # Delete the merged tags
                tag_names = [tag.name for tag in merge_tags]
                Tag.objects.filter(id__in=merge_tag_ids).delete()

                messages.success(
                    request,
                    f'Successfully merged {len(merge_tags)} tags ({", ".join(tag_names)}) into "{target_tag.name}".',
                )

            return HttpResponseRedirect(reverse("linkding:tags.index"))
        else:
            return turbo.stream(
                turbo.replace(
                    request,
                    "tag-modal",
                    "tags/merge.html",
                    {"form": form},
                    method="morph",
                )
            )

    return render(request, "tags/merge.html", {"form": form})


================================================
FILE: bookmarks/views/toasts.py
================================================
from django.contrib.auth.decorators import login_required
from django.http import HttpResponseRedirect
from django.urls import reverse

from bookmarks.utils import get_safe_return_url
from bookmarks.views import access


@login_required
def acknowledge(request):
    toast = access.toast_write(request, request.POST["toast"])
    toast.acknowledged = True
    toast.save()

    return_url = get_safe_return_url(
        request.GET.get("return_url"), reverse("linkding:bookmarks.index")
    )
    return HttpResponseRedirect(return_url)


================================================
FILE: bookmarks/views/turbo.py
================================================
from django.http import HttpRequest, HttpResponse
from django.template import loader


def accept(request: HttpRequest):
    is_turbo_request = "text/vnd.turbo-stream.html" in request.headers.get("Accept", "")
    disable_turbo = request.POST.get("disable_turbo", "false") == "true"

    return is_turbo_request and not disable_turbo


def is_frame(request: HttpRequest, frame: str) -> bool:
    return request.headers.get("Turbo-Frame") == frame


def frame(request: HttpRequest, template_name: str, context: dict) -> HttpResponse:
    """
    Renders the specified template into an HTML skeleton including <head> with
    respective metadata. The template should only contain a frame. Used for
    Turbo Frame requests that modify the top frame's URL.
    """
    html = loader.render_to_string("shared/top_frame.html", context, request)
    content = loader.render_to_string(template_name, context, request)
    html = html.replace("<!--content-->", content)
    response = HttpResponse(html, status=200)
    return response


def update(
    request: HttpRequest,
    target: str,
    template_name: str,
    context: dict,
    method: str | None = "",
) -> str:
    """Render a template wrapped in an update turbo-stream element."""
    content = loader.render_to_string(template_name, context, request)
    method_attr = f' method="{method}"' if method else ""
    return f'<turbo-stream action="update"{method_attr} target="{target}"><template>{content}</template></turbo-stream>'


def replace(
    request: HttpRequest,
    target: str,
    template_name: str,
    context: dict,
    method: str | None = "",
) -> str:
    """Render a template wrapped in a replace turbo-stream element."""
    content = loader.render_to_string(template_name, context, request)
    method_attr = f' method="{method}"' if method else ""
    return f'<turbo-stream action="replace"{method_attr} target="{target}"><template>{content}</template></turbo-stream>'


def stream(*streams: str) -> HttpResponse:
    """Combine multiple stream elements into a turbo-stream response."""
    return HttpResponse(
        "\n".join(streams),
        status=200,
        content_type="text/vnd.turbo-stream.html",
    )


================================================
FILE: bookmarks/widgets.py
================================================
from django import forms
from django.forms.utils import ErrorList
from django.utils.html import escape, format_html
from django.utils.safestring import mark_safe


class FormErrorList(ErrorList):
    template_name = "shared/error_list.html"


class FormInput(forms.TextInput):
    def __init__(self, attrs=None):
        default_attrs = {"class": "form-input", "autocomplete": "off"}
        if attrs:
            default_attrs.update(attrs)
        super().__init__(default_attrs)


class FormNumberInput(forms.NumberInput):
    def __init__(self, attrs=None):
        default_attrs = {"class": "form-input"}
        if attrs:
            default_attrs.update(attrs)
        super().__init__(default_attrs)


class FormSelect(forms.Select):
    def __init__(self, attrs=None):
        default_attrs = {"class": "form-select"}
        if attrs:
            default_attrs.update(attrs)
        super().__init__(default_attrs)


class FormTextarea(forms.Textarea):
    def __init__(self, attrs=None):
        default_attrs = {"class": "form-input"}
        if attrs:
            default_attrs.update(attrs)
        super().__init__(default_attrs)


class FormCheckbox(forms.CheckboxInput):
    def __init__(self, attrs=None):
        super().__init__(attrs)
        self.label = "Label"

    def render(self, name, value, attrs=None, renderer=None):
        checkbox_html = super().render(name, value, attrs, renderer)
        input_id = attrs.get("id") if attrs else None
        return format_html(
            '<div class="form-checkbox">'
            "{}"
            '<i class="form-icon"></i>'
            '<label for="{}">{}</label>'
            "</div>",
            checkbox_html,
            input_id,
            self.label,
        )


class TagAutocomplete(forms.TextInput):
    def __init__(self, attrs=None):
        super().__init__(attrs)

    def render(self, name, value, attrs=None, renderer=None):
        # Merge self.attrs with passed attrs
        final_attrs = self.build_attrs(self.attrs, attrs)

        input_id = final_attrs.get("id")
        input_value = escape(value) if value else ""
        aria_describedby = final_attrs.get("aria-describedby")
        input_class = final_attrs.get("class")

        html = f'<ld-tag-autocomplete input-id="{input_id}" input-name="{name}" input-value="{input_value}"'
        if aria_describedby:
            html += f' input-aria-describedby="{aria_describedby}"'
        if input_class:
            html += f' input-class="{input_class}"'
        html += "></ld-tag-autocomplete>"

        return mark_safe(html)


================================================
FILE: bookmarks/wsgi.py
================================================
"""
WSGI config for linkding.

It exposes the WSGI callable as a module-level variable named ``application``.
"""

import os

from django.core.wsgi import get_wsgi_application

os.environ.setdefault("DJANGO_SETTINGS_MODULE", "bookmarks.settings")

application = get_wsgi_application()


================================================
FILE: bootstrap.sh
================================================
#!/usr/bin/env bash
# Bootstrap script that gets executed in new Docker containers

LD_SERVER_HOST="${LD_SERVER_HOST:-[::]}"
LD_SERVER_PORT="${LD_SERVER_PORT:-9090}"

# Create data folder if it does not exist
mkdir -p data
# Create favicon folder if it does not exist
mkdir -p data/favicons
# Create previews folder if it does not exist
mkdir -p data/previews
# Create assets folder if it does not exist
mkdir -p data/assets

# Generate secret key file if it does not exist
python manage.py generate_secret_key
# Run database migration
python manage.py migrate
# Enable WAL journal mode for SQLite databases
python manage.py enable_wal
# Create initial superuser if defined in options / environment variables
python manage.py create_initial_superuser
# Migrate legacy background tasks to Huey
python manage.py migrate_tasks

# Ensure folders are owned by the right user
chown -R www-data: /etc/linkding/data

# Start processes
# Experimental: use supervisor to manage all processes, enables logging background tasks to stdout/stderr
if [ "$LD_SUPERVISOR_MANAGED" = "True" ]; then
  exec supervisord -c supervisord-all.conf
# Default: start background task processor as daemon, then uwsgi as main process
else
  if [ "$LD_DISABLE_BACKGROUND_TASKS" != "True" ]; then
    supervisord -c supervisord-tasks.conf
  fi
  exec uwsgi --http $LD_SERVER_HOST:$LD_SERVER_PORT uwsgi.ini
fi


================================================
FILE: docker/alpine.Dockerfile
================================================
FROM node:22-alpine AS node-build
WORKDIR /etc/linkding
# install build dependencies
COPY rollup.config.mjs postcss.config.js package.json package-lock.json ./
RUN npm ci
# copy files needed for JS build
COPY bookmarks/frontend ./bookmarks/frontend
COPY bookmarks/styles ./bookmarks/styles
# run build
RUN npm run build


FROM python:3.13.7-alpine3.22 AS build-deps
# Add required packages
# alpine-sdk linux-headers pkgconfig: build Python packages from source
# libpq-dev: build Postgres client from source
# icu-dev sqlite-dev: build Sqlite ICU extension
# libffi-dev openssl-dev rust cargo: build Python cryptography from source
RUN apk update && apk add alpine-sdk linux-headers libpq-dev pkgconfig icu-dev sqlite-dev libffi-dev openssl-dev rust cargo
WORKDIR /etc/linkding
# install uv, use installer script for now as distroless images are not availabe for armv7
ADD https://astral.sh/uv/0.8.13/install.sh /uv-installer.sh
RUN chmod +x /uv-installer.sh && /uv-installer.sh
# install python dependencies
COPY pyproject.toml uv.lock ./
RUN /root/.local/bin/uv sync --no-dev --group postgres


FROM build-deps AS compile-icu
# Defines SQLite version
# Since this is only needed for downloading the header files this probably
# doesn't need to be up-to-date, assuming the SQLite APIs used by the ICU
# extension do not change
ARG SQLITE_RELEASE_YEAR=2023
ARG SQLITE_RELEASE=3430000

# Compile the ICU extension needed for case-insensitive search and ordering
# with SQLite. This does:
# - Download SQLite amalgamation for header files
# - Download ICU extension source file
# - Compile ICU extension
RUN wget https://www.sqlite.org/${SQLITE_RELEASE_YEAR}/sqlite-amalgamation-${SQLITE_RELEASE}.zip && \
    unzip sqlite-amalgamation-${SQLITE_RELEASE}.zip && \
    cp sqlite-amalgamation-${SQLITE_RELEASE}/sqlite3.h ./sqlite3.h && \
    cp sqlite-amalgamation-${SQLITE_RELEASE}/sqlite3ext.h ./sqlite3ext.h && \
    wget https://www.sqlite.org/src/raw/ext/icu/icu.c?name=91c021c7e3e8bbba286960810fa303295c622e323567b2e6def4ce58e4466e60 -O icu.c && \
    gcc -fPIC -shared icu.c `pkg-config --libs --cflags icu-uc icu-io` -o libicu.so


FROM python:3.13.7-alpine3.22 AS linkding
LABEL org.opencontainers.image.source="https://github.com/sissbruecker/linkding"
# install runtime dependencies
RUN apk update && apk add bash curl icu libpq mailcap libssl3
# create www-data user and group
RUN set -x ; \
  addgroup -g 82 -S www-data ; \
  adduser -u 82 -D -S -G www-data www-data && exit 0 ; exit 1
WORKDIR /etc/linkding
# copy python dependencies
COPY --from=build-deps /etc/linkding/.venv /etc/linkding/.venv
# copy output from node build
COPY --from=node-build /etc/linkding/bookmarks/static bookmarks/static/
# copy compiled icu extension
COPY --from=compile-icu /etc/linkding/libicu.so libicu.so
# copy application code
COPY . .
# Activate virtual env
ENV VIRTUAL_ENV=/etc/linkding/.venv
ENV PATH="/etc/linkding/.venv/bin:$PATH"
# Generate static files, remove source styles that are not needed
RUN mkdir data && \
    python manage.py collectstatic

# Limit file descriptors used by uwsgi, see https://github.com/sissbruecker/linkding/issues/453
ENV UWSGI_MAX_FD=4096
# Expose uwsgi server at port 9090
EXPOSE 9090
# Allow running containers as an an arbitrary user in the root group, to support deployment scenarios like OpenShift, Podman
RUN chmod g+w . && \
    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"]


FROM node:22-alpine AS ublock-build
WORKDIR /etc/linkding
# Install necessary tools
# Download and unzip the latest uBlock Origin Lite release
# Patch manifest to enable annoyances by default
RUN apk add --no-cache curl jq unzip && \
    TAG=$(curl -sL https://api.github.com/repos/uBlockOrigin/uBOL-home/releases/latest | jq -r '.tag_name') && \
    DOWNLOAD_URL=https://github.com/uBlockOrigin/uBOL-home/releases/download/$TAG/uBOLite_$TAG.chromium.zip && \
    echo "Downloading $DOWNLOAD_URL" && \
    curl -L -o uBOLite.zip $DOWNLOAD_URL && \
    unzip uBOLite.zip -d uBOLite.chromium.mv3 && \
    rm uBOLite.zip && \
    jq '.declarative_net_request.rule_resources |= map(if .id == "annoyances-overlays" or .id == "annoyances-cookies" or .id == "annoyances-social" or .id == "annoyances-widgets" or .id == "annoyances-others" then .enabled = true else . end)' \
        uBOLite.chromium.mv3/manifest.json > temp.json && \
    mv temp.json uBOLite.chromium.mv3/manifest.json


FROM linkding AS linkding-plus
# install node, chromium
RUN apk update && apk add nodejs npm chromium-swiftshader
# install single-file-cli
RUN npm install -g single-file-cli@2.0.75
# copy uBlock
COPY --from=ublock-build /etc/linkding/uBOLite.chromium.mv3 uBOLite.chromium.mv3/
# create chromium profile folder for user running background tasks and set permissions
RUN mkdir -p chromium-profile &&  \
    chown -R www-data:www-data chromium-profile &&  \
    chown -R www-data:www-data uBOLite.chromium.mv3
# enable snapshot support
ENV LD_ENABLE_SNAPSHOTS=True


================================================
FILE: docker/default.Dockerfile
================================================
FROM node:22-alpine AS node-build
WORKDIR /etc/linkding
# install build dependencies
COPY rollup.config.mjs postcss.config.js package.json package-lock.json ./
RUN npm ci
# copy files needed for JS build
COPY bookmarks/frontend ./bookmarks/frontend
COPY bookmarks/styles ./bookmarks/styles
# run build
RUN npm run build


FROM python:3.13.7-slim-trixie AS build-deps
# Add required packages
# build-essential pkg-config: build Python packages from source
# libpq-dev: build Postgres client from source
# libicu-dev libsqlite3-dev: build Sqlite ICU extension
RUN apt-get update && apt-get -y install build-essential pkg-config libpq-dev libicu-dev libsqlite3-dev libffi-dev wget unzip
WORKDIR /etc/linkding
# install uv, use installer script for now as distroless images are not availabe for armv7
ADD https://astral.sh/uv/0.8.13/install.sh /uv-installer.sh
RUN chmod +x /uv-installer.sh && /uv-installer.sh
# install python dependencies
COPY pyproject.toml uv.lock ./
RUN /root/.local/bin/uv sync --no-dev --group postgres


FROM build-deps AS compile-icu
# Defines SQLite version
# Since this is only needed for downloading the header files this probably
# doesn't need to be up-to-date, assuming the SQLite APIs used by the ICU
# extension do not change
ARG SQLITE_RELEASE_YEAR=2023
ARG SQLITE_RELEASE=3430000

# Compile the ICU extension needed for case-insensitive search and ordering
# with SQLite. This does:
# - Download SQLite amalgamation for header files
# - Download ICU extension source file
# - Compile ICU extension
RUN wget https://www.sqlite.org/${SQLITE_RELEASE_YEAR}/sqlite-amalgamation-${SQLITE_RELEASE}.zip && \
    unzip sqlite-amalgamation-${SQLITE_RELEASE}.zip && \
    cp sqlite-amalgamation-${SQLITE_RELEASE}/sqlite3.h ./sqlite3.h && \
    cp sqlite-amalgamation-${SQLITE_RELEASE}/sqlite3ext.h ./sqlite3ext.h && \
    wget https://www.sqlite.org/src/raw/ext/icu/icu.c?name=91c021c7e3e8bbba286960810fa303295c622e323567b2e6def4ce58e4466e60 -O icu.c && \
    gcc -fPIC -shared icu.c `pkg-config --libs --cflags icu-uc icu-io` -o libicu.so


FROM python:3.13.7-slim-trixie AS linkding
LABEL org.opencontainers.image.source="https://github.com/sissbruecker/linkding"
# install runtime dependencies
RUN apt-get update && apt-get -y install media-types libpq-dev libicu-dev libssl3t64 curl
WORKDIR /etc/linkding
# copy python dependencies
COPY --from=build-deps /etc/linkding/.venv /etc/linkding/.venv
# copy output from node build
COPY --from=node-build /etc/linkding/bookmarks/static bookmarks/static/
# copy compiled icu extension
COPY --from=compile-icu /etc/linkding/libicu.so libicu.so
# copy application code
COPY . .
# Activate virtual env
ENV VIRTUAL_ENV=/etc/linkding/.venv
ENV PATH="/etc/linkding/.venv/bin:$PATH"
# Generate static files
RUN mkdir data && \
    python manage.py collectstatic

# Limit file descriptors used by uwsgi, see https://github.com/sissbruecker/linkding/issues/453
ENV UWSGI_MAX_FD=4096
# Expose uwsgi server at port 9090
EXPOSE 9090
# Allow running containers as an an arbitrary user in the root group, to support deployment scenarios like OpenShift, Podman
RUN chmod g+w . && \
    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"]


FROM node:22-alpine AS ublock-build
WORKDIR /etc/linkding
# Install necessary tools
# Download and unzip the latest uBlock Origin Lite release
# Patch manifest to enable annoyances by default
RUN apk add --no-cache curl jq unzip && \
    TAG=$(curl -sL https://api.github.com/repos/uBlockOrigin/uBOL-home/releases/latest | jq -r '.tag_name') && \
    DOWNLOAD_URL=https://github.com/uBlockOrigin/uBOL-home/releases/download/$TAG/uBOLite_$TAG.chromium.zip && \
    echo "Downloading $DOWNLOAD_URL" && \
    curl -L -o uBOLite.zip $DOWNLOAD_URL && \
    unzip uBOLite.zip -d uBOLite.chromium.mv3 && \
    rm uBOLite.zip && \
    jq '.declarative_net_request.rule_resources |= map(if .id == "annoyances-overlays" or .id == "annoyances-cookies" or .id == "annoyances-social" or .id == "annoyances-widgets" or .id == "annoyances-others" then .enabled = true else . end)' \
        uBOLite.chromium.mv3/manifest.json > temp.json && \
    mv temp.json uBOLite.chromium.mv3/manifest.json


FROM linkding AS linkding-plus
# install chromium
RUN apt-get update && apt-get -y install chromium
# install node
ENV NODE_MAJOR=22
RUN apt-get install -y gnupg2 apt-transport-https ca-certificates && \
    curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key | gpg --dearmor -o /usr/share/keyrings/nodesource.gpg && \
    echo "deb [signed-by=/usr/share/keyrings/nodesource.gpg] https://deb.nodesource.com/node_$NODE_MAJOR.x nodistro main" | tee /etc/apt/sources.list.d/nodesource.list && \
    apt-get update && apt-get install -y nodejs
# install single-file-cli
RUN npm install -g single-file-cli@2.0.75
# copy uBlock
COPY --from=ublock-build /etc/linkding/uBOLite.chromium.mv3 uBOLite.chromium.mv3/
# create chromium profile folder for user running background tasks and set permissions
RUN mkdir -p chromium-profile &&  \
    chown -R www-data:www-data chromium-profile &&  \
    chown -R www-data:www-data uBOLite.chromium.mv3
# enable snapshot support
ENV LD_ENABLE_SNAPSHOTS=True


================================================
FILE: docker-compose.yml
================================================
services:
  linkding:
    container_name: "${LD_CONTAINER_NAME:-linkding}"
    image: sissbruecker/linkding:latest
    ports:
      - "${LD_HOST_PORT:-9090}:9090"
    volumes:
      - "${LD_HOST_DATA_DIR:-./data}:/etc/linkding/data"
    env_file:
      - .env
    restart: unless-stopped

================================================
FILE: docs/.gitignore
================================================
# build output
dist/
# generated types
.astro/

# dependencies
node_modules/

# logs
npm-debug.log*
yarn-debug.log*
yarn-error.log*
pnpm-debug.log*


# environment variables
.env
.env.production

# macOS-specific files
.DS_Store


================================================
FILE: docs/README.md
================================================
# Starlight Starter Kit: Basics

[![Built with Starlight](https://astro.badg.es/v2/built-with-starlight/tiny.svg)](https://starlight.astro.build)

```
npm create astro@latest -- --template starlight
```

[![Open in StackBlitz](https://developer.stackblitz.com/img/open_in_stackblitz.svg)](https://stackblitz.com/github/withastro/starlight/tree/main/examples/basics)
[![Open with CodeSandbox](https://assets.codesandbox.io/github/button-edit-lime.svg)](https://codesandbox.io/p/sandbox/github/withastro/starlight/tree/main/examples/basics)
[![Deploy to Netlify](https://www.netlify.com/img/deploy/button.svg)](https://app.netlify.com/start/deploy?repository=https://github.com/withastro/starlight&create_from_path=examples/basics)
[![Deploy with Vercel](https://vercel.com/button)](https://vercel.com/new/clone?repository-url=https%3A%2F%2Fgithub.com%2Fwithastro%2Fstarlight%2Ftree%2Fmain%2Fexamples%2Fbasics&project-name=my-starlight-docs&repository-name=my-starlight-docs)

> 🧑‍🚀 **Seasoned astronaut?** Delete this file. Have fun!

## 🚀 Project Structure

Inside of your Astro + Starlight project, you'll see the following folders and files:

```
.
├── public/
├── src/
│   ├── assets/
│   ├── content/
│   │   ├── docs/
│   │   └── config.ts
│   └── env.d.ts
├── astro.config.mjs
├── package.json
└── tsconfig.json
```

Starlight looks for `.md` or `.mdx` files in the `src/content/docs/` directory. Each file is exposed as a route based on its file name.

Images can be added to `src/assets/` and embedded in Markdown with a relative link.

Static assets, like favicons, can be placed in the `public/` directory.

## 🧞 Commands

All commands are run from the root of the project, from a terminal:

| Command                   | Action                                           |
| :------------------------ | :----------------------------------------------- |
| `npm install`             | Installs dependencies                            |
| `npm run dev`             | Starts local dev server at `localhost:4321`      |
| `npm run build`           | Build your production site to `./dist/`          |
| `npm run preview`         | Preview your build locally, before deploying     |
| `npm run astro ...`       | Run CLI commands like `astro add`, `astro check` |
| `npm run astro -- --help` | Get help using the Astro CLI                     |

## 👀 Want to learn more?

Check out [Starlight’s docs](https://starlight.astro.build/), read [the Astro documentation](https://docs.astro.build), or jump into the [Astro Discord server](https://astro.build/chat).


================================================
FILE: docs/astro.config.mjs
================================================
// @ts-check
import { defineConfig } from "astro/config";
import starlight from "@astrojs/starlight";

// https://astro.build/config
export default defineConfig({
  integrations: [
    starlight({
      title: "linkding",
      logo: {
        src: "./src/assets/logo.svg",
      },
      social: [
        {
          icon: "github",
          label: "GitHub",
          href: "https://github.com/sissbruecker/linkding",
        },
      ],
      sidebar: [
        {
          label: "Getting Started",
          items: [
            { label: "Installation", slug: "installation" },
            { label: "Options", slug: "options" },
            { label: "Managed Hosting", slug: "managed-hosting" },
            { label: "Browser Extension", slug: "browser-extension" },
          ],
        },
        {
          label: "Guides",
          items: [
            { label: "Backups", slug: "backups" },
            { label: "Search", slug: "search" },
            { label: "Archiving", slug: "archiving" },
            { label: "Auto Tagging", slug: "auto-tagging" },
            { label: "Keyboard Shortcuts", slug: "shortcuts" },
            { label: "How To", slug: "how-to" },
            { label: "Troubleshooting", slug: "troubleshooting" },
            { label: "Admin", slug: "admin" },
            { label: "REST API", slug: "api" },
          ],
        },
        {
          label: "Resources",
          items: [
            { label: "Community", slug: "community" },
            { label: "Acknowledgements", slug: "acknowledgements" },
          ],
        },
      ],
      customCss: ["./src/styles/custom.css"],
      editLink: {
        baseUrl: "https://github.com/sissbruecker/linkding/edit/master/docs/",
      },
    }),
  ],
});


================================================
FILE: docs/package.json
================================================
{
  "name": "linkding-docs",
  "type": "module",
  "version": "1.0.0",
  "scripts": {
    "dev": "astro dev",
    "start": "astro dev",
    "build": "rm -rf dist && astro check && astro build",
    "preview": "astro preview",
    "astro": "astro"
  },
  "dependencies": {
    "@astrojs/starlight": "^0.37.1",
    "astro": "^5.6.1",
    "sharp": "^0.34.2"
  }
}


================================================
FILE: docs/src/assets/linkding_shortcut.json
================================================
{
  "categories": [
    {
      "id": "e260b423-db01-4743-a671-2cd38594c63c",
      "layoutType": "wide_grid",
      "name": "Shortcuts",
      "shortcuts": [
        {
          "bodyContent": "{{7b26d228-4ad6-4b1c-8b7b-076dc03385cc}}",
          "codeOnPrepare": "const sharedValue \u003d getVariable(\u0027text_and_url\u0027)\nconst matches \u003d sharedValue.match(/\\bhttps?:\\/\\/\\S+/gi);\nconst url \u003d matches[0];\nsetVariable(\u0027cleaned_url\u0027, url);",
          "contentType": "application/json",
          "description": "bookmark link",
          "headers": [
            {
              "id": "b66dd9b9-13e8-4802-b527-6e32f3980f4b",
              "key": "Authorization",
              "value": "Token {{908e3a30-ae82-400d-93c8-561c36d11d6d}}"
            }
          ],
          "iconName": "flat_grey_pin",
          "id": "871c3219-9e9f-46bb-8a7f-78f1496f78fc",
          "method": "POST",
          "name": "Linkding",
          "responseHandling": {
            "failureOutput": "simple",
            "uiType": "toast"
          },
          "url": "{{26253fe2-d202-4ce8-acd1-55c1ad3ae7d1}}/api/bookmarks/"
        }
      ]
    }
  ],
  "variables": [
    {
      "id": "26253fe2-d202-4ce8-acd1-55c1ad3ae7d1",
      "key": "linkding_instance",
      "value": "https://your.linkding.host.no.slashed.end"
    },
    {
      "id": "a3c8efa2-3e3a-4bb4-8919-3e831f95fe6a",
      "jsonEncode": true,
      "key": "linkding_tag",
      "message": "Comma separated",
      "title": "One or more tags",
      "type": "text"
    },
    {
      "id": "908e3a30-ae82-400d-93c8-561c36d11d6d",
      "key": "linkding_api_key",
      "value": "your_api_key_here"
    },
    {
      "id": "d76696e7-1ee1-4d98-b6f9-b570ec69ef40",
      "key": "cleaned_url"
    },
    {
      "flags": 1,
      "id": "da66cdad-8118-4a87-9581-4db33852b610",
      "key": "text_and_url",
      "message": "Any text that contains one URL",
      "title": "URL",
      "type": "text"
    },
    {
      "data": "{\"select\":{\"multi_select\":\"false\",\"separator\":\",\"}}",
      "id": "7b26d228-4ad6-4b1c-8b7b-076dc03385cc",
      "key": "tag_yes_no_default",
      "options": [
        {
          "id": "9365e43e-0572-4621-ac06-caec1ccff09d",
          "label": "Tagged",
          "value": "{{5be61e61-d8f5-475b-b1b1-88ddaebf8fd5}}"
        },
        {
          "id": "9f1caeaf-af57-42b4-8b10-4391354ad0f0",
          "label": "Untagged and unread",
          "value": "{{71ac9c4d-c03e-4b6f-ad75-9c112a591c50}}"
        }
      ],
      "title": "Tagged or unread?",
      "type": "select"
    },
    {
      "id": "5be61e61-d8f5-475b-b1b1-88ddaebf8fd5",
      "key": "request_body_tagged",
      "value": "{ \"url\": \"{{d76696e7-1ee1-4d98-b6f9-b570ec69ef40}}\", \"tag_names\": [ \"{{a3c8efa2-3e3a-4bb4-8919-3e831f95fe6a}}\" ] }"
    },
    {
      "id": "71ac9c4d-c03e-4b6f-ad75-9c112a591c50",
      "key": "request_body_untagged",
      "value": "{ \"url\": \"{{d76696e7-1ee1-4d98-b6f9-b570ec69ef40}}\", \"unread\": true }"
    }
  ],
  "version": 56
}


================================================
FILE: docs/src/components/Card.astro
================================================
---
import {icons} from './icons';
interface Props {
    icon: keyof typeof icons;
    title: string;
}

const {icon, title} = Astro.props;
---

<article class="card sl-flex">
  <p class="title sl-flex">
      {icon && <span class="icon" set:html={icons[icon]}/>}
    <span set:html={title}/>
  </p>
  <div class="body">
    <slot/>
  </div>
</article>

<style>
    .card {
        flex-direction: column;
        gap: clamp(0.5rem, calc(0.125rem + 1vw), 1rem);
    }

    .title {
        font-weight: 600;
        font-size: var(--sl-text-h4);
        color: var(--sl-color-white);
        line-height: var(--sl-line-height-headings);
        gap: .8rem;
        align-items: center;
    }

    .card .icon {
        border-radius: 0.25rem;
        color: var(--sl-color-text-accent);
    }

    .card .body {
        margin: 0;
        font-size: clamp(var(--sl-text-sm), calc(0.5rem + 1vw), var(--sl-text-body));
    }
</style>


================================================
FILE: docs/src/components/icons.ts
================================================
export const icons = {
    'focus': `<svg  xmlns="http://www.w3.org/2000/svg"  width="24"  height="24"  viewBox="0 0 24 24"  fill="none"  stroke="currentColor"  stroke-width="2"  stroke-linecap="round"  stroke-linejoin="round"><path stroke="none" d="M0 0h24v24H0z" fill="none"/><circle cx="12" cy="12" r=".5" fill="currentColor" /><path d="M12 12m-9 0a9 9 0 1 0 18 0a9 9 0 1 0 -18 0" /></svg>`,
    'settings': `<svg  xmlns="http://www.w3.org/2000/svg"  width="24"  height="24"  viewBox="0 0 24 24"  fill="none"  stroke="currentColor"  stroke-width="2"  stroke-linecap="round"  stroke-linejoin="round"><path stroke="none" d="M0 0h24v24H0z" fill="none"/><path d="M10.325 4.317c.426 -1.756 2.924 -1.756 3.35 0a1.724 1.724 0 0 0 2.573 1.066c1.543 -.94 3.31 .826 2.37 2.37a1.724 1.724 0 0 0 1.065 2.572c1.756 .426 1.756 2.924 0 3.35a1.724 1.724 0 0 0 -1.066 2.573c.94 1.543 -.826 3.31 -2.37 2.37a1.724 1.724 0 0 0 -2.572 1.065c-.426 1.756 -2.924 1.756 -3.35 0a1.724 1.724 0 0 0 -2.573 -1.066c-1.543 .94 -3.31 -.826 -2.37 -2.37a1.724 1.724 0 0 0 -1.065 -2.572c-1.756 -.426 -1.756 -2.924 0 -3.35a1.724 1.724 0 0 0 1.066 -2.573c-.94 -1.543 .826 -3.31 2.37 -2.37c1 .608 2.296 .07 2.572 -1.065z" /><path d="M9 12a3 3 0 1 0 6 0a3 3 0 0 0 -6 0" /></svg>`,
    'plus': `<svg  xmlns="http://www.w3.org/2000/svg"  width="24"  height="24"  viewBox="0 0 24 24"  fill="none"  stroke="currentColor"  stroke-width="2"  stroke-linecap="round"  stroke-linejoin="round"><path stroke="none" d="M0 0h24v24H0z" fill="none"/><path d="M12 5l0 14" /><path d="M5 12l14 0" /></svg>`,
    'archive': `<svg  xmlns="http://www.w3.org/2000/svg"  width="24"  height="24"  viewBox="0 0 24 24"  fill="none"  stroke="currentColor"  stroke-width="2"  stroke-linecap="round"  stroke-linejoin="round"><path stroke="none" d="M0 0h24v24H0z" fill="none"/><path d="M3 4m0 2a2 2 0 0 1 2 -2h14a2 2 0 0 1 2 2v0a2 2 0 0 1 -2 2h-14a2 2 0 0 1 -2 -2z" /><path d="M5 8v10a2 2 0 0 0 2 2h10a2 2 0 0 0 2 -2v-10" /><path d="M10 12l4 0" /></svg>`,
    'checkbox': `<svg  xmlns="http://www.w3.org/2000/svg"  width="24"  height="24"  viewBox="0 0 24 24"  fill="none"  stroke="currentColor"  stroke-width="2"  stroke-linecap="round"  stroke-linejoin="round"><path stroke="none" d="M0 0h24v24H0z" fill="none"/><path d="M3 3m0 2a2 2 0 0 1 2 -2h14a2 2 0 0 1 2 2v14a2 2 0 0 1 -2 2h-14a2 2 0 0 1 -2 -2z" /><path d="M9 12l2 2l4 -4" /></svg>`,
    'file-export': `<svg  xmlns="http://www.w3.org/2000/svg"  width="24"  height="24"  viewBox="0 0 24 24"  fill="none"  stroke="currentColor"  stroke-width="2"  stroke-linecap="round"  stroke-linejoin="round"><path stroke="none" d="M0 0h24v24H0z" fill="none"/><path d="M14 3v4a1 1 0 0 0 1 1h4" /><path d="M11.5 21h-4.5a2 2 0 0 1 -2 -2v-14a2 2 0 0 1 2 -2h7l5 5v5m-5 6h7m-3 -3l3 3l-3 3" /></svg>`,
    'users': `<svg  xmlns="http://www.w3.org/2000/svg"  width="24"  height="24"  viewBox="0 0 24 24"  fill="none"  stroke="currentColor"  stroke-width="2"  stroke-linecap="round"  stroke-linejoin="round"><path stroke="none" d="M0 0h24v24H0z" fill="none"/><path d="M9 7m-4 0a4 4 0 1 0 8 0a4 4 0 1 0 -8 0" /><path d="M3 21v-2a4 4 0 0 1 4 -4h4a4 4 0 0 1 4 4v2" /><path d="M16 3.13a4 4 0 0 1 0 7.75" /><path d="M21 21v-2a4 4 0 0 0 -3 -3.85" /></svg>`,
    'login': `<svg  xmlns="http://www.w3.org/2000/svg"  width="24"  height="24"  viewBox="0 0 24 24"  fill="none"  stroke="currentColor"  stroke-width="2"  stroke-linecap="round"  stroke-linejoin="round"><path stroke="none" d="M0 0h24v24H0z" fill="none"/><path d="M15 8v-2a2 2 0 0 0 -2 -2h-7a2 2 0 0 0 -2 2v12a2 2 0 0 0 2 2h7a2 2 0 0 0 2 -2v-2" /><path d="M21 12h-13l3 -3" /><path d="M11 15l-3 -3" /></svg>`,
    'puzzle': `<svg  xmlns="http://www.w3.org/2000/svg"  width="24"  height="24"  viewBox="0 0 24 24"  fill="none"  stroke="currentColor"  stroke-width="2"  stroke-linecap="round"  stroke-linejoin="round"><path stroke="none" d="M0 0h24v24H0z" fill="none"/><path d="M4 7h3a1 1 0 0 0 1 -1v-1a2 2 0 0 1 4 0v1a1 1 0 0 0 1 1h3a1 1 0 0 1 1 1v3a1 1 0 0 0 1 1h1a2 2 0 0 1 0 4h-1a1 1 0 0 0 -1 1v3a1 1 0 0 1 -1 1h-3a1 1 0 0 1 -1 -1v-1a2 2 0 0 0 -4 0v1a1 1 0 0 1 -1 1h-3a1 1 0 0 1 -1 -1v-3a1 1 0 0 1 1 -1h1a2 2 0 0 0 0 -4h-1a1 1 0 0 1 -1 -1v-3a1 1 0 0 1 1 -1" /></svg>`,
    'cloud': `<svg  xmlns="http://www.w3.org/2000/svg"  width="24"  height="24"  viewBox="0 0 24 24"  fill="none"  stroke="currentColor"  stroke-width="2"  stroke-linecap="round"  stroke-linejoin="round"><path stroke="none" d="M0 0h24v24H0z" fill="none"/><path d="M6.657 18c-2.572 0 -4.657 -2.007 -4.657 -4.483c0 -2.475 2.085 -4.482 4.657 -4.482c.393 -1.762 1.794 -3.2 3.675 -3.773c1.88 -.572 3.956 -.193 5.444 1c1.488 1.19 2.162 3.007 1.77 4.769h.99c1.913 0 3.464 1.56 3.464 3.486c0 1.927 -1.551 3.487 -3.465 3.487h-11.878" /></svg>`,
    'mood-smile': `<svg  xmlns="http://www.w3.org/2000/svg"  width="24"  height="24"  viewBox="0 0 24 24"  fill="none"  stroke="currentColor"  stroke-width="2"  stroke-linecap="round"  stroke-linejoin="round"  class="icon icon-tabler icons-tabler-outline icon-tabler-mood-smile"><path stroke="none" d="M0 0h24v24H0z" fill="none"/><path d="M12 12m-9 0a9 9 0 1 0 18 0a9 9 0 1 0 -18 0" /><path d="M9 10l.01 0" /><path d="M15 10l.01 0" /><path d="M9.5 15a3.5 3.5 0 0 0 5 0" /></svg>`,
}

================================================
FILE: docs/src/content/config.ts
================================================
import { defineCollection } from 'astro:content';
import { docsSchema } from '@astrojs/starlight/schema';

export const collections = {
	docs: defineCollection({ schema: docsSchema() }),
};


================================================
FILE: docs/src/content/docs/acknowledgements.md
================================================
---
title: "Acknowledgements"
description: "Acknowledgements and thanks to contributors and sponsors"
---

## PikaPods

[PikaPods](https://www.pikapods.com/) has a revenue sharing agreement with this project, sharing some of their revenue from hosting linkding instances. I do not intend to profit from this project financially, so I am in turn donating that revenue. Thanks to PikaPods for making this possible.

See the table below for a list of donations.

<table>
  <thead>
    <tr>
      <th>Source</th>
      <th>Description</th>
      <th>Amount</th>
      <th>Donated to</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><a href="https://www.pikapods.com/">PikaPods</a></td>
      <td>Linkding hosting June 2022 - September 2023</td>
      <td>$163.50</td>
      <td><a href="/donations/2023-10-11-internet-archive.png">Internet Archive</a></td>
    </tr>
    <tr>
      <td><a href="https://www.pikapods.com/">PikaPods</a></td>
      <td>Linkding hosting October 2023 - September 2024</td>
      <td>$287.04</td>
      <td>
        <a href="/donations/2024-10-04-django.png">Django</a><br>
        <a href="/donations/2024-10-04-singlefile.png">SingleFile</a><br>
        <a href="/donations/2024-10-04-internet-archive.png">Internet Archive</a><br>
        <a href="/donations/2024-10-04-noyb.png">NOYB</a>
      </td>
    </tr>
  </tbody>
</table>

## JetBrains

JetBrains has previously provided an open-source license of [IntelliJ IDEA](https://www.jetbrains.com/idea/) for the development of linkding. Thanks!


================================================
FILE: docs/src/content/docs/admin.md
================================================
---
title: "Admin"
description: "How to use the linkding admin app"
---

This document describes how to make use of the admin app that comes as part of each linkding installation. This is the default Django admin app with some linkding specific customizations.

The admin app provides several features that are not available in the linkding UI:
- User management and user self-management
- Bookmark and tag management, including bulk operations

## Linkding administration page

To open the Admin app, go the *Settings* view and click on the *Admin* tab. This should open a new window with the admin app.

Alternatively you can open the URL directly by adding `/admin` to the URL of your linkding installation.

## User management

Go to the linkding administration page and select *Users*.
Here you can add and delete users, and change the password of a user.

Once you have added a user you can, if needed, give the user staff status, which means this user can also access the linkding administration page.

This page also allows you to change your own password if necessary.

## Bookmark management

While the linkding UI itself now has a bulk edit feature for bookmarks you can also use the admin app to manage bookmarks or to do bulk operations. 

In the main linkding administration page, choose *Bookmarks*.

First select the bookmarks to operate on:

- Specify a filter to determine which bookmarks to operate on:
  - In the column *by username*, you can choose to filter for bookmarks for a specific user
  - In the column *by is archived*, you can choose to filter for bookmarks that are either archived or not
  - In the column *by tags*, you can choose to filter for specific tags
  - In the search box you can also add a text filter (note that this doesn't use the same search syntax as the linkding UI itself)  

Now a list of bookmarks which match your filter is displayed, each bookmark on a separate line.
Each line starts with a checkbox.
Either choose the individual bookmarks you want to do a bulk operation on, or choose the top checkbox to select all shown bookmarks.

Open the "Action" select box to choose the desired bulk operation:

- Delete
- Archive
- Unarchive

Click the button next to the checkbox to execute the operation.

## Tag management

While linkding UI currently only allows to create or assign tags, you can use the admin app to manage your tags. This can be especially useful if you want to clean up your tag collection.

In the main linkding administration page, choose *Tags*.

Similar to bookmarks management described above you can now specify which tags to operate on by specifying a filter and then selecting the individual tags.

Open the "Action" select box to choose the desired bulk operation:

- Delete
- Delete unused tags - this will only delete the selected tags that are currently not assigned to any bookmark

Click the button next to the checkbox to execute the operation.

Note that deleting a tag does not affect the bookmarks that are tagged with this tag, it only removes the tag from those bookmarks.


================================================
FILE: docs/src/content/docs/api.md
================================================
---
title: "API"
description: "How to use the REST API of linkding"
---

The application provides a REST API that can be used by 3rd party applications to manage bookmarks.

## Authentication

All requests against the API must be authorized using an authorization token. The application automatically generates an
API token for each user, which can be accessed through the *Settings* page.

The token needs to be passed as `Authorization` header in the HTTP request:

```
Authorization: Token <Token>
```

## Resources

The following resources are available:

### Bookmarks

**List**

```
GET /api/bookmarks/
```

List bookmarks.

Parameters:

- `q` - Filters results using a search phrase using the same logic as through the UI
- `limit` - Limits the max. number of results. Default is `100`.
- `offset` - Index from which to start returning results
- `modified_since` - Filter results to only include bookmarks modified after the specified date (format: ISO 8601, e.g. "2025-01-01T00:00:00Z")
- `added_since` - Filter results to only include bookmarks added after the specified date (format: ISO 8601, e.g. "2025-05-29T00:00:00Z")
- `bundle` - Filter results by bundle id to only include bookmarks matched by a given bundle

Example response:

```json
{
  "count": 123,
  "next": "http://127.0.0.1:8000/api/bookmarks/?limit=100&offset=100",
  "previous": null,
  "results": [
    {
      "id": 1,
      "url": "https://example.com",
      "title": "Example title",
      "description": "Example description",
      "notes": "Example notes",
      "web_archive_snapshot_url": "https://web.archive.org/web/20200926094623/https://example.com",
      "favicon_url": "http://127.0.0.1:8000/static/https_example_com.png",
      "preview_image_url": "http://127.0.0.1:8000/static/0ac5c53db923727765216a3a58e70522.jpg",
      "is_archived": false,
      "unread": false,
      "shared": false,
      "tag_names": [
        "tag1",
        "tag2"
      ],
      "date_added": "2020-09-26T09:46:23.006313Z",
      "date_modified": "2020-09-26T16:01:14.275335Z"
    },
    ...
  ]
}
```

**List Archived**

```
GET /api/bookmarks/archived/
```

List archived bookmarks.

Parameters and response are the same as for the regular list endpoint.

**Retrieve**

```
GET /api/bookmarks/<id>/
```

Retrieves a single bookmark by ID.

**Check**

```
GET /api/bookmarks/check/?url=https%3A%2F%2Fexample.com
```

Allows to check if a URL is already bookmarked. If the URL is already bookmarked, the `bookmark` property in the
response holds the bookmark data, otherwise it is `null`.

Also returns a `metadata` property that contains metadata scraped from the website. Finally, the `auto_tags` property
contains the tag names that would be automatically added when creating a bookmark for that URL.

Example response:

```json
{
  "bookmark": {
    "id": 1,
    "url": "https://example.com",
    "title": "Example title",
    "description": "Example description",
    ...
  },
  "metadata": {
    "title": "Scraped website title",
    "description": "Scraped website description",
    ...
  },
  "auto_tags": [
    "tag1",
    "tag2"
  ]
}
```

**Create**

```
POST /api/bookmarks/
```

Creates a new bookmark. Tags are simply assigned using their names. Including
`is_archived: true` saves a bookmark directly to the archive.

If the provided URL is already bookmarked, this silently updates the existing bookmark instead of creating a new one. If
you are implementing a user interface, consider notifying users about this behavior. You can use the `/check` endpoint
to check if a URL is already bookmarked and at the same time get the existing bookmark data. This behavior may change in
the future to return an error instead.

If the title and description are not provided or empty, the application automatically tries to scrape them from the
bookmarked website. This behavior can be disabled by adding the `disable_scraping` query parameter to the API request.

Example payload:

```json
{
  "url": "https://example.com",
  "title": "Example title",
  "description": "Example description",
  "notes": "Example notes",
  "is_archived": false,
  "unread": false,
  "shared": false,
  "tag_names": [
    "tag1",
    "tag2"
  ]
}
```

**Update**

```
PUT /api/bookmarks/<id>/
PATCH /api/bookmarks/<id>/
```

Updates a bookmark.
When using `POST`, at least all required fields must be provided (currently only `url`).
When using `PATCH`, only the fields that should be updated need to be provided.
Regardless which method is used, any field that is not provided is not modified.
Tags are simply assigned using their names.

If the provided URL is already bookmarked this returns an error.

Example payload:

```json
{
  "url": "https://example.com",
  "title": "Example title",
  "description": "Example description",
  "tag_names": [
    "tag1",
    "tag2"
  ]
}
```

**Archive**

```
POST /api/bookmarks/<id>/archive/
```

Archives a bookmark.

**Unarchive**

```
POST /api/bookmarks/<id>/unarchive/
```

Unarchives a bookmark.

**Delete**

```
DELETE /api/bookmarks/<id>/
```

Deletes a bookmark by ID.

### Bookmark Assets

**List**

```
GET /api/bookmarks/<bookmark_id>/assets/
```

List assets for a specific bookmark.

Example response:

```json
{
  "count": 2,
  "next": null,
  "previous": null,
  "results": [
    {
      "id": 1,
      "bookmark": 1,
      "asset_type": "snapshot",
      "date_created": "2023-10-01T12:00:00Z",
      "content_type": "text/html",
      "display_name": "HTML snapshot from 10/01/2023",
      "status": "complete"
    },
    {
      "id": 2,
      "bookmark": 1,
      "asset_type": "upload",
      "date_created": "2023-10-01T12:05:00Z",
      "content_type": "image/png",
      "display_name": "example.png",
      "status": "complete"
    }
  ]
}
```

**Retrieve**

```
GET /api/bookmarks/<bookmark_id>/assets/<id>/
```

Retrieves a single asset by ID for a specific bookmark.

**Download**

```
GET /api/bookmarks/<bookmark_id>/assets/<id>/download/
```

Downloads the asset file.

**Upload**

```
POST /api/bookmarks/<bookmark_id>/assets/upload/
```

Uploads a new asset for a specific bookmark. The request must be a `multipart/form-data` request with a single part
named `file` containing the file to upload.

Example response:

```json
{
  "id": 3,
  "bookmark": 1,
  "asset_type": "upload",
  "date_created": "2023-10-01T12:10:00Z",
  "content_type": "application/pdf",
  "display_name": "example.pdf",
  "status": "complete"
}
```

**Delete**

```
DELETE /api/bookmarks/<bookmark_id>/assets/<id>/
```

Deletes an asset by ID for a specific bookmark.

### Tags

**List**

```
GET /api/tags/
```

List tags.

Parameters:

- `limit` - Limits the max. number of results. Default is `100`.
- `offset` - Index from which to start returning results

Example response:

```json
{
  "count": 123,
  "next": "http://127.0.0.1:8000/api/tags/?limit=100&offset=100",
  "previous": null,
  "results": [
    {
      "id": 1,
      "name": "example",
      "date_added": "2020-09-26T09:46:23.006313Z"
    },
    ...
  ]
}
```

**Retrieve**

```
GET /api/tags/<id>/
```

Retrieves a single tag by ID.

**Create**

```
POST /api/tags/
```

Creates a new tag.

Example payload:

```json
{
  "name": "example"
}
```

### Bundles

**List**

```
GET /api/bundles/
```

List bundles.

Parameters:

- `limit` - Limits the max. number of results. Default is `100`.
- `offset` - Index from which to start returning results

Example response:

```json
{
  "count": 3,
  "next": null,
  "previous": null,
  "results": [
    {
      "id": 1,
      "name": "Work Resources",
      "search": "productivity tools",
      "any_tags": "work productivity",
      "all_tags": "",
      "excluded_tags": "personal",
      "order": 0,
      "date_created": "2020-09-26T09:46:23.006313Z",
      "date_modified": "2020-09-26T16:01:14.275335Z"
    },
    {
      "id": 2,
      "name": "Tech Articles",
      "search": "",
      "any_tags": "programming development",
      "all_tags": "",
      "excluded_tags": "outdated",
      "order": 1,
      "date_created": "2020-09-27T10:15:30.123456Z",
      "date_modified": "2020-09-27T10:15:30.123456Z"
    },
    ...
  ]
}
```

**Retrieve**

```
GET /api/bundles/<id>/
```

Retrieves a single bundle by ID.

**Create**

```
POST /api/bundles/
```

Creates a new bundle. If no `order` is specified, the bundle will be automatically assigned the next available order position.

Example payload:

```json
{
  "name": "My Bundle",
  "search": "search terms",
  "any_tags": "tag1 tag2",
  "all_tags": "required-tag",
  "excluded_tags": "excluded-tag",
  "order": 5
}
```

**Update**

```
PUT /api/bundles/<id>/
PATCH /api/bundles/<id>/
```

Updates a bundle.
When using `PUT`, all fields except read-only ones should be provided.
When using `PATCH`, only the fields that should be updated need to be provided.

Example payload:

```json
{
  "name": "Updated Bundle Name",
  "search": "updated search terms",
  "any_tags": "new-tag1 new-tag2",
  "order": 10
}
```

**Delete**

```
DELETE /api/bundles/<id>/
```

Deletes a bundle by ID.

### User

**Profile**

```
GET /api/user/profile/
```

User preferences.

Example response:

```json
{
  "theme": "auto",
  "bookmark_date_display": "relative",
  "bookmark_link_target": "_blank",
  "web_archive_integration": "enabled",
  "tag_search": "lax",
  "enable_sharing": true,
  "enable_public_sharing": true,
  "enable_favicons": false,
  "display_url": false,
  "permanent_notes": false,
  "search_preferences": {
    "sort": "title_asc",
    "shared": "off",
    "unread": "off"
  }
}
```


================================================
FILE: docs/src/content/docs/archiving.md
================================================
---
title: "Archiving"
description: "How to archive web pages with linkding"
---

Linkding allows to archive bookmarked web pages as HTML files. This can be useful to preserve the content of a web page in case it goes offline or its content changes. The sections below explain different methods to archive web pages and store them in linkding.

## Server-based Archiving

Linkding can automatically create HTML snapshots whenever a bookmark is added. This feature is only available in the `latest-plus` Docker image (see [Installation](/installation#using-docker)), and is automatically active when using that image.

The snapshots are created using [singlefile-cli](https://github.com/gildas-lormeau/single-file-cli), which effectively runs a headless Chromium instance on the server to convert the web page into a single HTML file. Linkding will also load the [uBlock Origin Lite extension](https://github.com/uBlockOrigin/uBOL-home) into Chromium to attempt to block ads and other unwanted content.

When bookmarking a URL that points directly to a PDF file, linkding will download the PDF instead of creating an HTML snapshot. This happens automatically based on the content type of the URL, and the downloaded PDF will be stored as an asset alongside the bookmark, just like HTML snapshots.

This method is fairly easy to set up, but also has several downsides:
- The Docker image is significantly larger than the base image, as it includes a Chromium installation.
- Running Chromium requires significantly more memory, at least 1 GB of RAM.
- The Docker image is not available for ARM v7 platforms.
- Creating snapshots from a headless browser is not always reliable, for example:
  - It may trigger anti-bot measures on the website.
  - Websites that require login will not show the same content you would see in your browser.

Read on for alternative methods to archive web pages directly from your browser, which do not require the `latest-plus` Docker image and will save the web page exactly as you see it in your browser.

## Using the Singlefile Browser Extension

[Singlefile](https://github.com/gildas-lormeau/SingleFile) is a popular browser extension for saving a web page as a single HTML file. By default, the extension saves the file to your local disk, but it can also be configured to send the file to a REST API endpoint. Linkding provides a REST API endpoint for this purpose.

To use the Singlefile extension with linkding, follow these steps:
- Install the [Singlefile extension](https://github.com/gildas-lormeau/SingleFile) in your browser
- Open the extension's settings
- Under `Destination`, select `upload to a REST Form API`
- Under `URL` enter the URL of your linkding installation, followed by `/api/bookmarks/singlefile/` (e.g. `https://linkding.example.com/api/bookmarks/singlefile/`)
- Under `authorization token`, enter the REST API token that you can get from your linkding settings page
- Under `data field name` enter `file`
- Under `URL field name` enter `url`

Now, when you click the Singlefile extension icon, the web page will be saved as a single HTML file and uploaded to your linkding installation.
Note that if a bookmark for that URL does not exist, linkding will automatically create a new bookmark. If a bookmark already exists, the snapshot will be added to the existing bookmark.

Using this method has some downsides, in that you can not provide any additional metadata to the bookmark, such as tags or a description. Read on for how to use the linkding extension directly to create bookmarks with metadata and run the Singlefile extension.

## Using the linkding Browser Extension

The linkding extension allows you to quickly add bookmarks from your browser. It can also integrate with the Singlefile extension to automatically create a snapshot of the web page when adding a bookmark.

To integrate with the Singlefile extension, follow these steps:
- First, install and configure the Singlefile extension as described above so that it uploads files to your linkding installation
- Open the linkding extension settings
- Enable the `Run Singlefile after adding new bookmark` option
- Save the settings

Now, when you add a bookmark through the linkding extension, it will automatically trigger the Singlefile extension to create a snapshot of the web page, which will then be uploaded to your linkding installation and stored under the newly added bookmark.

Note that when the option is enabled, linkding will not attempt to create an HTML snapshot on the server, even if you are using the `latest-plus` Docker image. The linkding extension will not trigger Singlefile when updating an existing bookmark. If you want to create a new snapshot for an existing bookmark, you can do so manually by clicking the Singlefile extension icon.

### Extension Store Compatibility

The linkding and Singlefile extensions communicate using store-specific extension IDs. For the integration to work, both extensions must be installed from the same browser extension store. For example:
- If you install linkding from the Chrome Web Store, install Singlefile from the Chrome Web Store as well
- If you install linkding from Firefox Add-ons, install Singlefile from Firefox Add-ons as well

This is particularly relevant for Microsoft Edge users, as Edge can install extensions from both the Chrome Web Store and the Microsoft Edge Add-ons store. If the extensions are installed from different stores, the automatic Singlefile integration will not work.


================================================
FILE: docs/src/content/docs/auto-tagging.md
================================================
---
title: "Auto tagging"
description: "How to automatically assign tags to bookmarks based on predefined rules"
---

Auto tagging allows to automatically add tags to bookmarks based on predefined rules. This makes categorizing commonly
bookmarked websites easier and faster.

Auto tagging rules can be defined in the profile settings. Each rule maps a URL pattern to one or more tags. For
example:

```
youtube.com video
reddit.com/r/Music music reddit
```

When a bookmark is created or updated, the URL of the bookmark is parsed to extract the hostname, path, query
string and fragment. These components are then compared against the patterns defined in the auto tagging rules. If all components
match, the tags associated with the rule are added to the bookmark. Both the bookmark form in the web interface and the
browser extension will show a preview of the tags that will be added based on the auto tagging rules.

The URL matching works like this:

- **Hostname Matching**: The hostname of the bookmark URL is compared to the hostname in the rule. If the rule does not
  specify a subdomain, it matches all subdomains. For example, a rule with `youtube.com` will match both
  `www.youtube.com` and `m.youtube.com`. If a subdomain is specified in the rule, it will only match that subdomain. For
  example, a rule with `gist.github.com` will only match `gist.github.com`.
- **Path Matching**: The path of the bookmark URL is compared to the path in the rule. If the rule does not specify a
  path, it matches all paths. For example, a rule with `reddit.com` will match `reddit.com/r/music`,
  `reddit.com/r/gaming`, etc. If a path is specified in the rule, it will only match that path and all its subpaths. For
  example, a rule with `reddit.com/r/music` will match `reddit.com/r/music`, `reddit.com/r/music/new`, etc.
- **Query String Matching**: The query string parameters of the bookmark URL are compared to those in the rule. If the
  rule does not specify any query string parameters, it matches all query strings. If the rule specifies a query string
  it will only match if the bookmark URL contains all the specified query string parameters with their respective
  values.
- **Fragment Matching**: The URL fragment (part after the # symbol) is also compared when present in a rule. If the rule
  specifies a fragment, it will match any URL whose fragment starts with the specified fragment. For example, a rule with
  `example.com/#/projects` will match URLs like `example.com/#/projects/123` or `example.com/#/projects/456`.

Note that URL matching currently does not support any kind of wildcards. Rule matching only works based on the URL, not
on the content of the website or any other aspect of the bookmark.

## Example

Consider the following auto tagging rule:

```
reddit.com/r/Music music reddit
```

When adding a bookmark for a URL like `https://www.reddit.com/r/Music/comments/...`, the auto tagging mechanism will:

1. Parse the URL to extract the hostname (`www.reddit.com`), path (`/r/Music/comments/...`), and query string (none).
2. Match the hostname against the pattern. The domain `reddit.com` matches. Since the rule does not specify a subdomain,
   it also matches `www.reddit.com`.
3. Match the path against the pattern. The path `/r/Music` also matches the nested path `/r/Music/comments/...`.
4. Match the query string. Since the rule does not specify a query string, it matches all query strings.
5. The tags `music` and `reddit` will be added to the bookmark.


================================================
FILE: docs/src/content/docs/backups.md
================================================
---
title: "Backups"
description: "How to back up your Linkding installation"
---

Linkding stores all data in the application's data folder.
The full path to that folder in the Docker container is `/etc/linkding/data`.
As described in the installation docs, you should mount the `/etc/linkding/data` folder to a folder on your host system.

The data folder contains the following contents that are relevant for backups:
- `db.sqlite3` - the SQLite database
- `assets` - folder that contains HTML snapshots of bookmarks
- `favicons` - folder that contains downloaded favicons
- `previews` - folder that contains downloaded preview images

The following sections explain how to back up the individual contents.

## Full backup

linkding provides a CLI command to create a full backup of the data folder. This creates a zip file that contains backups of the database, assets, favicons, and preview images.

:::note
This method assumes that you are using the default SQLite database.
If you are using a different database, such as Postgres, you'll have to back up the database and other contents of the data folder manually.
:::

To create a full backup, execute the following command:
```shell
docker exec -it linkding python manage.py full_backup /etc/linkding/data/backup.zip
```
This creates a `backup.zip` file in the Docker container under `/etc/linkding/data`.

To copy the backup file to your host system, execute the following command:
```shell
docker cp linkding:/etc/linkding/data/backup.zip backup.zip
```
This copies the backup file from the Docker container to the current folder on your host system.
Now you can move that file to your backup location.

To restore a backup: 
- Extract the zip file in a folder of your new installation.
- Rename the extracted folder to `data`.
- When starting the Docker container, mount that folder to `/etc/linkding/data` as explained in the README.
- Then start the Docker container.

## Alternative backup methods

If you can't use the full backup method, this section describes alternatives how to back up the individual contents of the data folder.

### SQLite database backup

linkding includes a CLI command for creating a backup copy of the database.

:::caution
While the SQLite database is just a single file, it is not recommended to just copy that file.
This method is not transaction safe and may result in a [corrupted database](https://www.sqlite.org/howtocorrupt.html).
Use one of the backup methods described below.
:::

:::caution
This method is deprecated and may be removed in the future.
Please use the full backup method described above.
:::

To create a backup, execute the following command:
```shell
docker exec -it linkding python manage.py backup /etc/linkding/data/backup.sqlite3
```
This creates a `backup.sqlite3` file in the Docker container under `/etc/linkding/data`.

To copy the backup file to your host system, execute the following command:
```shell
docker cp linkding:/etc/linkding/data/backup.sqlite3 backup.sqlite3
```
This copies the backup file from the Docker container to the current folder on your host system.
Now you can move that file to your backup location.

To restore the backup, just copy the backup file to the data folder of your new installation and rename it to `db.sqlite3`. Then start the Docker container.

### SQLite database SQL dump

Requires [SQLite](https://www.sqlite.org/index.html) to be installed on your host system.

With this method you create a plain text file with the SQL statements to recreate the SQLite database.
To create a backup, execute the following command in the data folder on your host system:
```shell
sqlite3 db.sqlite3 .dump > backup.sql
```
This creates a `backup.sql` which you can copy to your backup location.
As this is a plain text file you can also commit it to any revision management system, like git.
Using git, you can commit the changes, followed by a git push to a remote repository.

### Exporting bookmarks from the UI

This is the least technical option to back up bookmarks, but has several limitations:
- It does not export user profiles.
- It only exports your own bookmarks, not those of other users.
- It does not export URLs of snapshots on the Internet Archive Wayback machine.
- It does not export HTML snapshots of bookmarks. Even if you backup and restore the assets folder, the bookmarks will not be linked to the snapshots anymore.
- It does not export favicons or preview images.

Only use this method if you are fine with the above limitations.

To export bookmarks from the UI, open the general settings.
In the Export section, click on the *Download* button to download an HTML file containing all your bookmarks.
Then move that file to your backup location.

To restore bookmarks, open the general settings on your new installation.
In the Import section, click on the *Choose file* button to select the HTML file you downloaded before.
Then click on the *Import* button to import the bookmarks.

### Assets

If you are using the HTML snapshots feature, you should also do backups of the `assets` folder.
It contains the HTML snapshots files of your bookmarks which are referenced from the database.

To back up the assets, then you have to copy the `assets` folder to your backup location.

To restore the assets, copy the `assets` folder back to the data folder of your new installation.

### Favicons

Doing a backup of the icons is optional, as they can be downloaded again.

If you choose not to back up the icons, you can just restore the database and then click the _Refresh Favicons_ button in the general settings.
This will download all missing icons again.

If you want to back up the icons, then you have to copy the `favicons` folder to your backup location.

To restore the icons, copy the `favicons` folder back to the data folder of your new installation.


================================================
FILE: docs/src/content/docs/browser-extension.md
================================================
---
title: "Browser Extension"
description: "Browser extension for linkding"
---

linkding comes with an official browser extension that allows to quickly add bookmarks, and search bookmarks through the browser's address bar. You can get the extension here:
- [Mozilla Addon Store](https://addons.mozilla.org/firefox/addon/linkding-extension/)
- [Chrome Web Store](https://chrome.google.com/webstore/detail/linkding-extension/beakmhbijpdhipnjhnclmhgjlddhidpe)

The extension is open-source as well, and can be found [here](https://github.com/sissbruecker/linkding-extension).


================================================
FILE: docs/src/content/docs/community.md
================================================
---
title: "Community"
description: "Community projects around linkding"
---

This section lists community projects around using linkding. If you have a project that you want to share with the linkding community, feel free to [submit a PR](https://github.com/sissbruecker/linkding/edit/master/docs/src/content/docs/community.md) to add your project to this section.

## Mobile and Desktop Apps

| Name | Description | Author |
| ---- | ----------- | ------ |
| [cosmicding](https://github.com/vkhitrin/cosmicding) | Desktop client built using [libcosmic](https://github.com/pop-os/libcosmic). | [vkhitrin](https://github.com/vkhitrin) |
| [LinkBuddy](https://github.com/peterto/LinkBuddy) | An open-source Android and iOS client for linkding, written in React Native. Android apk available on [github](https://github.com/peterto/LinkBuddy/releases) and iOS version on [Apple AppStore](https://apps.apple.com/us/app/linkbuddy-for-linkding/id6740408952). | [peterto](https://github.com/peterto) |
| [Linkdy](https://github.com/JGeek00/linkdy) | An open-source Android and iOS client created with Flutter. Available on the [Google Play Store](https://play.google.com/store/apps/details?id=com.jgeek00.linkdy) and [App Store](https://apps.apple.com/us/app/linkdy/id6479930976). | [JGeek00](https://github.com/JGeek00) |
| [Linklater](https://github.com/danielyrovas/linklater) | An open-source Android client written in Kotlin. | [danielyrovas](https://github.com/danielyrovas) |
| [LinkThing](https://apps.apple.com/us/app/linkthing/id1666031776) | An iOS client for linkding. | [amoscardino](https://github.com/amoscardino) |
| [Pinkt](https://github.com/fibelatti/pinboard-kotlin) | An Android client for linkding. | [fibelatti](https://github.com/fibelatti) |

## Browser Extensions

| Name | Description | Author |
| ---- | ----------- | ------ |
| [linkding-extension](https://github.com/jeroenpardon/linkding-extension) | An alternative to the official browser extension that wraps the linkding bookmarklet. | [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. | [Fivefold](https://github.com/Fivefold) |

## Web and CLI Apps

| Name | Description | Author |
| ---- | ----------- | ------ |
| [DingDrop](https://github.com/marb08/DingDrop) | A Telegram bot that allows you to quickly save bookmarks to your Linkding instance via Telegram using Linkding APIs. | [marb08](https://github.com/marb08) |
| [feed2linkding](https://codeberg.org/strubbl/feed2linkding) | A commandline utility to add all web feed item links to linkding via API call. | [Strubbl](https://github.com/Strubbl) |
| [Komrade](https://codeberg.org/kodemonaut/komrade) | A simple docker based startpage/dashboard which syncs with Linkding, Linkwarden or Nextcloud Bookmarks. | [kodemonaut](https://codeberg.org/kodemonaut) |
| [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. | [cmsax](https://github.com/cmsax) |
| [linkding-archiver](https://github.com/sebw/linkding-archiver) | A Python application that integrates with SingleFile and Tube Archivist to archive your links and videos. | [sebw](https://github.com/sebw) |
| [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). | [bachya](https://github.com/bachya) |
| [linkdinger](https://github.com/lmmendes/linkdinger) | A Telegram bot that saves links directly to Linkding, with support for tags, notes, and searching bookmarks. | [lmmendes](https://github.com/lmmendes) |
| [linkding-healthcheck](https://github.com/sebw/linkding-healthcheck) | A Go application that checks the health of your bookmarks and add a tag on dead and problematic URLs. | [sebw](https://github.com/sebw) |
| [linkding-media-archiver](https://github.com/proog/linkding-media-archiver) | Automatically downloads media files for your bookmarks with yt-dlp and makes them available within Linkding. | [proog](https://github.com/proog) |
| [linkding-reminder](https://github.com/sebw/linkding-reminder) | A Python application that will send an email reminder for links with a specific tag. | [sebw](https://github.com/sebw) |
| [linktiles](https://github.com/haondt/linktiles) | A web app that displays your links as tiles in a configurable mosaic. | [haondt](https://github.com/haondt) |
| [Pocket2Linkding](https://github.com/hkclark/Pocket2Linkding/) | A tool to migrate from Mozilla Pocket to linkding. Preserves the date the link was added to pocket and any tags. | [hkclark](https://github.com/hkclark) |
| [serchding](https://github.com/ldwgchen/serchding) | Full-text search for linkding. | [ldwgchen](https://github.com/ldwgchen) |

## Utilities

| Name | Description | Author |
| ---- | ----------- | ------ |
| [alfred-linkding-bookmarks](https://github.com/firefingers21/alfred-linkding-bookmarks) | An Alfred workflow for searching and opening linkding bookmarks. | [FireFingers21](https://github.com/FireFingers21) |
| [Helm Chart](https://charts.pascaliske.dev/charts/linkding/) | Helm Chart for deploying linkding inside a Kubernetes cluster. | [pascaliske](https://github.com/pascaliske) |
| [iOS Shortcut using API and Tagging](https://gist.github.com/andrewdolphin/a7dff49505e588d940bec55132fab8ad) | An iOS shortcut using the Linkding API (no extra logins required) that pulls previously used tags and allows tagging at the time of link creation. | [andrewdolphin](https://github.com/andrewdolphin) |
| [iOS Shortcut and workflow](https://joshdick.net/2025/01/23/how_i_use_linkding_on_ios.html) | iOS shortcut that accepts URLs in various ways, and shows a corresponding Linkding add/edit webview in a modal popup. | [joshdick](https://joshdick.net) |
| [k8s + s3](https://github.com/jzck/linkding-k8s-s3) | Setup for hosting stateless linkding on k8s with sqlite replicated to s3. | [jzck](https://github.com/jzck) |
| [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. | [ukcuddlyguy](https://github.com/ukcuddlyguy) |
| [Postman collection](https://gist.github.com/gingerbeardman/f0b42502f3bc9344e92ce63afd4360d3) | A group of saved request templates for API testing. | [gingerbeardman](https://github.com/gingerbeardman) |

## Libraries

| Name | Description | Author |
| ---- | ----------- | ------ |
| [aiolinkding](https://github.com/bachya/aiolinkding) | A Python3, async library to interact with the linkding REST API. | [bachya](https://github.com/bachya) |
| [go-linkding](https://github.com/piero-vic/go-linkding) | A Go client library to interact with the linkding REST API. | [piero-vic](https://github.com/piero-vic) |
| [linkding-api](https://github.com/vbsampath/linkding-api) | A Javascript library implementing linkding REST API. | [vbsampath](https://github.com/vbsampath) |
| [linkding-rs](https://github.com/zbrox/linkding-rs) | A Rust client library to interact with the linkding REST API with cross platform support to be easily used in Android or iOS apps. | [zbrox](https://github.com/zbrox) |



================================================
FILE: docs/src/content/docs/how-to.md
================================================
---
title: "How to"
description: "Collection of tips and tricks around using linkding"
---

Collection of tips and tricks around using linkding.

## Using the bookmarklet on Android/Chrome

This how-to explains the usage of the standard linkding bookmarklet on Android / Chrome. 

Chrome on Android does not permit running bookmarklets in the same way you can on a desktop system. There is however a workaround that is explained here.

**Note** that this only works with Chrome and not with other browsers on Android.

Create a bookmark of your linkding deployment by clicking the star icon which you find in the three dots menu in the top right. Next you have to edit the bookmark. Edit the URL and replace it it with the bookmarklet code of your instance and give it an easy to type name like `bm` for bookmark or `ld` for linkding:

```
javascript:window.open(`http://<YOUR_INSTANCE_HERE>/bookmarks/new?url=${encodeURIComponent(window.location)}&auto_close`)
```

Now when you are browsing the web and you want to save the current page as a bookmark to your linkding instance simply type `bm` into the address bar and select it from the results. The bookmarklet code will trigger and you will be redirected so save the current page.

For more info see here: https://paul.kinlan.me/use-bookmarklets-on-chrome-on-android/

## Using the PWA (Progressive Web App) to save links using the native share sheet on Android

 - Visit your instance in Chrome (works best) or another Chromium-based web browser.
 - A popup should appear (first time only) prompting you to install Linkding as an app. If it doesn't, tap the 3-dot menu then tap "Add to Home screen", then tap "Install".
 - Linkding will now show up in Android's native share sheet. Share a link from any app or browser and tap Linkding to save a link.
 - Optional: when the share sheet is displayed, tap and hold Linkding, then tap "Pin" to pin it to the top.

## Using HTTP Shortcuts app on Android

**Note** This allows you to share URL from any app to tag and bookmark it to linkding

- Install HTTP Shortcuts from [Play Store](https://play.google.com/store/apps/details?id=ch.rmy.android.http_shortcuts) or [F-Droid](https://f-droid.org/en/packages/ch.rmy.android.http_shortcuts/).

- Copy the URL of [linkding_shortcut.json](https://raw.githubusercontent.com/sissbruecker/linkding/master/docs/src/assets/linkding_shortcut.json).

- Open HTTP Shortcuts, tap the 3-dot-button at the top-right corner, tap `Import/Export`, then tap `Import from URL`.

- Paste the URL you copied earlier, tap OK, go back, tap the 3-dot-button again, then tap `Variables`.

- Edit the `values` of `linkding_instance` and `linkding_api_key`.

Try using share button on an app, a new item `Send to...` should appear on the share sheet. You can also manually share by tapping the shortcut inside the HTTP Shortcuts app itself.

## Create a share action on iOS for adding bookmarks to linkding

This how-to explains how to make use of the app shortcuts iOS app to create a share action that can be used in Safari for adding bookmarks to your linkding instance.

To install the shortcut:
- Download the [Shortcut](https://raw.githubusercontent.com/sissbruecker/linkding/master/docs/src/assets/Add%20To%20Linkding.shortcut) on your iOS device
- Tap the downloaded file, which brings up the Shortcuts app
- Confirm that you want to add the shortcut
- In the shortcut, change `https://linkding.mydomain.com` to the URL of your linkding instance
- Confirm / close the shortcut

To use the shortcut:
- Open Safari and navigate to the page you want to bookmark
- Tap the share button
- Scroll down and tap "Add To Linkding"
- This opens linkding in a Safari overlay where you can configure the bookmark
- When you're done, tap "Save"
- After the bookmark is saved you can close the overlay

At the bottom of the share sheet there is a button for configuring share actions. You can use this to move the "Add To Linkding" action to the top of the share sheet if you like.

:::note
You can also check the [Community section](/community) for other pre-made shortcuts that you can use.
:::

## Increase the font size

The font size can be adjusted globally by adding the following CSS to the custom CSS field in the settings:

```css
:root {
  --font-size: 0.75rem;
  --font-size-sm: 0.7rem;
  --font-size-lg: 0.9rem;
}

.bookmark-list {
  line-height: 1.15rem;
}

.tag-cloud {
  line-height: 1.15rem;
}
```

You can adjust the `--font-size`, `--font-size-sm` and `--font-size-lg` variables to your liking.
Note that increasing the font might also require you to adjust the line-height in certain places to better separate texts from each other.
As an example, the above also increases the font size and line height of the bookmark list and tag cloud.


================================================
FILE: docs/src/content/docs/index.mdx
================================================
---
title: linkding
description: A self-hosted bookmarking service that is designed to be minimal, fast and easy to set up.
template: splash
hero:
  tagline: A self-hosted bookmark manager designed to be minimal, fast, and easy to set up.
  actions:
    - text: Get started
      link: /installation
      icon: right-arrow
    - text: GitHub
      link: https://github.com/sissbruecker/linkding
      icon: external
      variant: minimal
      attrs:
        target: _blank
    - text: Demo
      link: https://demo.linkding.link
      icon: external
      variant: minimal
      attrs:
        target: _blank
---

import { CardGrid } from '@astrojs/starlight/components';
import Card from '../../components/Card.astro';

<a href="/linkding-screenshot.png" className="hero-image light">
<img src="/linkding-screenshot.png"/>
</a>
<a href="/linkding-screenshot-dark.png" className="hero-image dark">
<img src="/linkding-screenshot-dark.png"/>
</a>


## Features

<CardGrid>
	<Card title="Focused" icon="focus">
		Optimized for readability, allowing to quickly add and find bookmarks without distractions.
	</Card>
	<Card title="Customizable" icon="settings">
		Features can be enabled or disabled as needed, adjustable UI through a number of settings.
	</Card>
	<Card title="Metadata" icon="plus">
		Automatically fetches titles, descriptions, icons and preview images of bookmarked websites.
	</Card>
	<Card title="Archiving" icon="archive">
		Automatically create snapshots of bookmarked websites, either as local HTML file or on the Internet Archive.
	</Card>
	<Card title="Bulk editing" icon="checkbox">
		Apply any operation to a selection of bookmarks or the whole collection.
	</Card>
	<Card title="Import / Export" icon="file-export">
		Import and export bookmarks in the Netscape HTML format.
	</Card>
	<Card title="Multi-User" icon="users">
		Supports multiple users, with the ability to share bookmarks with other users or guests.
	</Card>
	<Card title="Browser extension" icon="puzzle">
		Extensions for [Firefox](https://addons.mozilla.org/firefox/addon/linkding-extension/) and [Chrome](https://chrome.google.com/webstore/detail/linkding-extension/beakmhbijpdhipnjhnclmhgjlddhidpe) allow adding and searching bookmarks from within the browser.
	</Card>
	<Card title="REST API" icon="cloud">
		REST API for developing scripts or 3rd party apps.
	</Card>
	<Card title="Low maintenance" icon="mood-smile">
		A single Docker container, using SQLite as database. Automated migrations, zero breaking changes.
	</Card>
</CardGrid>


================================================
FILE: docs/src/content/docs/installation.md
================================================
---
title: "Installation"
description: "How to install linkding"
---

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 uses an SQLite database by default.
Alternatively, linkding supports PostgreSQL, see the [database options](/options#ld_db_engine) for more information.

##  Using Docker

The Docker image comes in several variants. To use a different image than the default, replace `latest` with the desired tag in the commands below, or in the docker-compose file.

<table>
  <thead>
    <tr>
      <th>Tag</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><code>latest</code></td>
      <td>Provides the basic functionality of linkding</td>
    </tr>
    <tr>
      <td><code>latest-plus</code></td>
      <td>
        Includes feature for archiving websites as HTML snapshots
        <ul>
          <li>Significantly larger image size as it includes a Chromium installation</li>
          <li>Requires more runtime memory to run Chromium</li>
          <li>Requires more disk space for storing HTML snapshots</li>
        </ul>            
      </td>
    </tr>
    <tr>
      <td><code>latest-alpine</code></td>
      <td><code>latest</code>, but based on Alpine Linux. 🧪 Experimental</td>
    </tr>    
    <tr>
      <td><code>latest-plus-alpine</code></td>
      <td><code>latest-plus</code>, but based on Alpine Linux. 🧪 Experimental</td>
    </tr>    
  </tbody>
</table>

To install linkding using Docker you can just run the image from either [Docker Hub](https://hub.docker.com/repository/docker/sissbruecker/linkding) or [GitHub Container Registry](https://github.com/sissbruecker/linkding/pkgs/container/linkding):
```shell
# Using Docker Hub
docker run --name linkding -p 9090:9090 -v {host-data-folder}:/etc/linkding/data -d sissbruecker/linkding:latest

# Using GitHub Container Registry
docker run --name linkding -p 9090:9090 -v {host-data-folder}:/etc/linkding/data -d ghcr.io/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.

##  Using Docker Compose

To install linkding using [Docker Compose](https://docs.docker.com/compose/), you can download the [`docker-compose.yml`](https://github.com/sissbruecker/linkding/blob/master/docker-compose.yml) file. Also download the [`.env.sample`](https://github.com/sissbruecker/linkding/blob/master/.env.sample) file, rename it to `.env`, configure the parameters, and then run:
```shell
docker-compose up -d
```

To complete the setup, you still have to [create an initial user](#user-setup), so that you can access your installation.

## User Setup

The linkding Docker image does not provide an initial user, so you have to create one after setting up an installation. To do so, replace the credentials in the following command and run it:

**Docker**
```shell
docker exec -it linkding python manage.py createsuperuser --username=joe --email=joe@example.com
```

**Docker Compose**
```shell
docker-compose exec linkding python manage.py createsuperuser --username=joe --email=joe@example.com
```

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](/options#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](/options#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](/options#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](/options#ld_csrf_trusted_origins).


================================================
FILE: docs/src/content/docs/managed-hosting.md
================================================
---
title: "Managed Hosting"
description: "Managed hosting options for linkding"
---

Self-hosting web applications still requires a lot of technical know-how and commitment to maintenance, in order to keep everything up-to-date and secure. This section is intended to provide simple alternatives in form of managed hosting solutions.

## Fully Managed

The following services provide fully managed hosting for linkding, including automatic updates and backups:

- [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) ([Disclosure](/acknowledgements#pikapods))
- [CloudBreak](https://cloudbreak.app/products/linkding/?utm_medium=referral&utm_source=linkding-docs&utm_content=managed-hosting&rby=linkding-docs-managed-hosting) - Managed hosting for linkding, US regions available.

## Self-Managed

The following guides provide instructions for hosting a linkding installation on various platforms, however you are still responsible for updates and backups:

- [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)
- [CapRover](https://caprover.com/) - Linkding is included as a default one-click app
- [linkding on railway.app](https://github.com/tianheg/linkding-on-railway) - Guide for hosting a linkding installation on [railway.app](https://railway.app/). By [tianheg](https://github.com/tianheg)


================================================
FILE: docs/src/content/docs/options.md
================================================
---
title: "Options"
description: "Options for configuring linkding"
---

This document lists the options that linkding can be configured with and explains how to use them in the individual install scenarios.

## Using options

### Docker

Options are passed as environment variables to the Docker container by using the `-e` argument when using `docker run`. For example:

```
docker run --name linkding -p 9090:9090 -d -e LD_DISABLE_URL_VALIDATION=True sissbruecker/linkding:latest
```

For multiple options, use one `-e` argument per option.

### Docker-compose

For docker-compose options are configured using an `.env` file.
Follow the docker-compose setup in the README and copy `.env.sample` to `.env`. Then modify the options in `.env`.

## List of options

### `LD_SUPERUSER_NAME`

Values: `String` | Default = None

When set, creates an initial superuser with the specified username when starting the container.
Does nothing if the user already exists.

See [`LD_SUPERUSER_PASSWORD`](#ld_superuser_password) on how to configure the respective password.

### `LD_SUPERUSER_PASSWORD`

Values: `String` | Default = None

The password for the initial superuser.
When left undefined, the superuser will be created without a usable password, which means the user can not authenticate using credentials / through the login form, and can only be authenticated using proxy authentication (see [`LD_ENABLE_AUTH_PROXY`](#ld_enable_auth_proxy)).

### `LD_DISABLE_BACKGROUND_TASKS`

Values: `True`, `False` | Default = `False`

Disables background tasks, such as creating snapshots for bookmarks on the [the Internet Archive Wayback Machine](https://archive.org/web/).
Enabling this flag will prevent the background task processor from starting up, and prevents scheduling tasks.
This might be useful if you are experiencing performance issues or other problematic behaviour due to background task processing.

### `LD_SUPERVISOR_MANAGED` (Experimental)

Values: `True`, `False` | Default = `False`

Changes how processes are managed within the container.
When enabled, supervisor manages both the background task processor and the web server (uwsgi).
This enables background task logs to appear in the container output (visible via `docker logs`).
At the moment, supervisor will automatically restart crashed processes and the `LD_DISABLE_BACKGROUND_TASKS` setting is ignored.

When disabled (default), the background task processor runs as a daemon and uwsgi runs as the main process.
Background task logs are written to a file (`background_tasks.log`) instead of the container output.

### `LD_DISABLE_URL_VALIDATION`

Values: `True`, `False` | Default = `False`

Completely disables URL validation for bookmarks.
This can be useful if you intend to store non fully qualified domain name URLs, such as network paths, or you want to store URLs that use another protocol than `http` or `https`.

### `LD_REQUEST_MAX_CONTENT_LENGTH`

Values: `Integer` as bytes | Default = `None`

Configures the maximum content length for POST requests in the uwsgi application server. This can be used to prevent uploading large files that might cause the server to run out of memory. By default, the server does not limit the content length.

### `LD_REQUEST_TIMEOUT`

Values: `Integer` as seconds | Default = `60`

Configures the request timeout in the uwsgi application server. This can be useful if you want to import a bookmark file with a high number of bookmarks and run into request timeouts.

### `LD_SERVER_HOST`

Values: Valid address for socket to bind to | Default = `[::]`

Allows to set a custom host for the UWSGI server running in the container. The default creates a dual stack socket, which will respond to IPv4 and IPv6 requests. IPv4 requests are logged as IPv4-mapped IPv6 addresses, such as "::ffff:127.0.0.1". If reverting to an IPv4-only socket is desired, this can be set to "0.0.0.0".

### `LD_SERVER_PORT`

Values: Valid port number | Default = `9090`

Allows to set a custom port for the UWSGI server running in the container. While Docker containers have their own IP address namespace and port collisions are impossible to achieve, there are other container solutions that share one. Podman, for example, runs all containers in a pod under one namespace, which results in every port only being allowed to be assigned once. This option allows to set a custom port in order to avoid collisions with other containers.

### `LD_CONTEXT_PATH`

Values: `String` | Default = None

Allows configuring the context path of the website. Useful for setting up Nginx reverse proxy.
The context path must end with a slash. For example: `linkding/`

### `LD_ENABLE_AUTH_PROXY`

Values: `True`, `False` | Default = `False`

Enables support for authentication proxies such as Authelia.
This effectively disables credentials-based authentication and instead authenticates users if a specific request header contains a known username.
You must make sure that your proxy (nginx, Traefik, Caddy, ...) forwards this header from your auth proxy to linkding. Check the documentation of your auth proxy and your reverse proxy on how to correctly set this up.

Note that this automatically creates new users in the database if they do not already exist.

Enabling this setting also requires configuring the following options:
- `LD_AUTH_PROXY_USERNAME_HEADER` - The name of the request header that the auth proxy passes to the proxied application (linkding in this case), so that the application can identify the user.
Check the documentation of your auth proxy to get this information.
Note that the request headers are rewritten in linkding: all HTTP headers are prefixed with `HTTP_`, all letters are in uppercase, and dashes are replaced with underscores.
For example, for Authelia, which passes the `Remote-User` HTTP header, the `LD_AUTH_PROXY_USERNAME_HEADER` needs to be configured as `HTTP_REMOTE_USER`.
- `LD_AUTH_PROXY_LOGOUT_URL` - The URL that linkding should redirect to after a logout.
By default, the logout redirects to the login URL, which means the user will be automatically authenticated again.
Instead, you might want to configure the logout URL of the auth proxy here.

### `LD_ENABLE_OIDC`

Values: `True`, `False` | Default = `False`

Enables support for OpenID Connect (OIDC) authentication, allowing to use single sign-on (SSO) with OIDC providers.
When enabled, this shows a button on the login page that allows users to authenticate using an OIDC provider.
Users are associated by the email address provided from the OIDC provider, which is by default also used as username in linkding. You can configure a custom claim to be used as username with `OIDC_USERNAME_CLAIM`.
If there is no user with that email address as username, a new user is created automatically.

This requires configuring a number of options, which of those you need depends on which OIDC provider you use and how it is configured.
In general, you should find the required information in the UI of your OIDC provider, or its documentation.

The options are adopted from the [mozilla-django-oidc](https://mozilla-django-oidc.readthedocs.io/en/stable/) library, which is used by linkding for OIDC support.
Please check their documentation for more information on the options.

The following options can be configured:
- `OIDC_OP_AUTHORIZATION_ENDPOINT` - The authorization endpoint of the OIDC provider.
- `OIDC_OP_TOKEN_ENDPOINT` - The token endpoint of the OIDC provider.
- `OIDC_OP_USER_ENDPOINT` - The user info endpoint of the OIDC provider.
- `OIDC_OP_JWKS_ENDPOINT` - The JWKS endpoint of the OIDC provider.
- `OIDC_RP_CLIENT_ID` - The client ID of the application.
- `OIDC_RP_CLIENT_SECRET` - The client secret of the application.
- `OIDC_RP_SIGN_ALGO` - The algorithm the OIDC provider uses to sign ID tokens. Default is `RS256`.
- `OIDC_USE_PKCE` - Whether to use PKCE for the OIDC flow. Default is `True`.
- `OIDC_VERIFY_SSL` - Whether to verify the SSL certificate of the OIDC provider. Set to `False` if using self-signed certificates or custom certificate authority. Default is `True`.
- `OIDC_RP_SCOPES` - Scopes asked for on the authorization flow. Default is `oidc email profile`.
- `OIDC_USERNAME_CLAIM` - A custom claim to used as username for new accounts, for example `preferred_username`. If the configured claim does not exist or is empty, the email claim is used as fallback. Default is `email`.

#### `OIDC` and `LD_SUPERUSER_NAME`

As noted above, OIDC matches users by email address, but `LD_SUPERUSER_NAME` will only set the username.
Instead of setting `LD_SUPERUSER_NAME` it is recommended that you use the method described in [User setup](/installation#user-setup) to configure a superuser with both username and email address.
This way when OIDC searches for a matching user it will find the superuser account you created.
Note that you should create the superuser **before** logging in with OIDC for the first time.

<details>

<summary>Authelia Example</summary>

#### Linkding Configuration

```bash
LD_ENABLE_OIDC=True
OIDC_OP_AUTHORIZATION_ENDPOINT=https://auth.example.com/api/oidc/authorization
OIDC_OP_TOKEN_ENDPOINT=https://auth.example.com/api/oidc/token
OIDC_OP_USER_ENDPOINT=https://auth.example.com/api/oidc/userinfo
OIDC_OP_JWKS_ENDPOINT=https://auth.example.com/jwks.json
OIDC_RP_CLIENT_ID=linkding
OIDC_RP_CLIENT_SECRET=myClientSecret
```
#### Authelia Configuration

```yaml
identity_providers:
  oidc:
    # --- more OIDC provider configuration ---

    clients:
      - id: linkding
        description: Linkding
        # docker run --rm authelia/authelia:latest authelia crypto rand --length 64 --charset alphanumeric
        secret: myClientSecret
        public: false
        token_endpoint_auth_method: client_secret_post
        scopes:
          - openid
          - email
          - profile
        redirect_uris:
          - https://linkding.example.com/oidc/callback/
```

</details>

### `LD_DISABLE_LOGIN_FORM`

Values: `True`, `False` | Default = `False`

Disables the login form on the login page.
This is useful when you want to enforce authentication through OIDC only.
When enabled, users will not be able to log in using their username and password, and only the "Login with OIDC" button will be shown on the login page.

### `LD_CSRF_TRUSTED_ORIGINS`

Values: `String` | Default = None

List of trusted origins / host names to allow for `POST` requests, for example when logging in, or saving bookmarks.
For these type of requests, the `Origin` header must match the `Host` header, otherwise the request will fail with a `403` status code, and the message `CSRF verification failed.`

This option allows to declare a list of trusted origins that will be accepted even if the headers do not match. This can be the case when using a reverse proxy that rewrites the `Host` header, such as Nginx.

For example, to allow requests to https://linkding.mydomain.com, configure the setting to `https://linkding.mydomain.com`.
Note that the setting **must** include the correct protocol (`https` or `http`), and **must not** include the application / context path.
Multiple origins can be specified by separating them with a comma (`,`).

This setting is adopted from the Django framework used by linkding, more information on the setting is available in the [Django documentation](https://docs.djangoproject.com/en/4.0/ref/settings/#std-setting-CSRF_TRUSTED_ORIGINS).

### `LD_USE_X_FORWARDED_HOST`

Values: `true` or `false` | Default =  `false`

If enabled the server will trust the `X-Forwarded-Host` header over the `Host` header to determine the hostname of the server. This should only be enabled if a proxy which sets this header is in use.

This setting is adopted from the Django framework used by linkding, more information on the setting is available in the [Django documentation](https://docs.djangoproject.com/en/6.0/ref/settings/#std-setting-USE_X_FORWARDED_HOST).

### `LD_LOG_X_FORWARDED_FOR`

Values: `true` or `false` | Default =  `false`

Set uWSGI [log-x-forwarded-for](https://uwsgi-docs.readthedocs.io/en/latest/Options.html?#log-x-forwarded-for) parameter allowing to keep the real IP of clients in logs when using a reverse proxy.

### `LD_DB_ENGINE`

Values: `postgres` or `sqlite` | Default = `sqlite`

Database engine used by linkding to store data.
Currently, linkding supports SQLite and PostgreSQL.
By default, linkding uses SQLite, for which you don't need to configure anything.
All the other database variables below are only required for configured PostgresSQL.

### `LD_DB_DATABASE`

Values: `String` | Default =  `linkding`

The name of the database.

### `LD_DB_USER`

Values: `String` | Default =  `linkding`

The name of the user to connect to the database server.

### `LD_DB_PASSWORD`

Values: `String` | Default =  None

The password of the user to connect to the database server.
The password must be configured when using a database other than SQLite, there is no default value.

### `LD_DB_HOST`

Values: `String` | Default =  `localhost`

The hostname or IP of the database server.

### `LD_DB_PORT`

Values: `Integer` | Default =  None

The port of the database server.
Should use the default port if left empty, for example `5432` for PostgresSQL.

### `LD_DB_OPTIONS`

Values: `String` | Default = `{}`

A json string with additional options for the database. Passed directly to OPTIONS.

### `LD_FAVICON_PROVIDER`

Values: `String` | Default =  `https://t1.gstatic.com/faviconV2?client=SOCIAL&type=FAVICON&fallback_opts=TYPE,SIZE,URL&url={url}&size=32`

The favicon provider used for downloading icons if they are enabled in the user profile settings.
The default provider is a Google service that automatically detects the correct favicon for a website, and provides icons in consistent image format (PNG) and in a consistent image size.

This setting allows to configure a custom provider in form of a URL.
When calling the provider with the URL of a website, it must return the image data for the favicon of that website.
The configured favicon provider URL must contain a placeholder that will be replaced with the URL of the website for which to download the favicon.
The available placeholders are:
- `{url}` - Includes the scheme and hostname of the website, for example `https://example.com`
- `{domain}` - Includes only the hostname of the website, for example `example.com`

Which placeholder you need to use depends on the respective favicon provider, please check their documentation or usage examples.
See the default URL for how to insert the placeholder to the favicon provider URL.

Alternative favicon providers:
- DuckDuckGo: `https://icons.duckduckgo.com/ip3/{domain}.ico`


### `LD_SINGLEFILE_TIMEOUT_SEC`

Values: `Float` | Default =  60.0

When creating HTML archive snapshots, control the timeout for how long to wait for the snapshot to complete, in `seconds`.
Defaults to 60 seconds; on lower-powered hardware you may need to increase this value.

### `LD_SINGLEFILE_OPTIONS`

Values: `String` | Default = None

When creating HTML archive snapshots, pass additional options to the `single-file` application that is used to create snapshots.
See `single-file --help` for complete list of arguments, or browse source: https://github.com/gildas-lormeau/single-file-cli/blob/master/options.js

Example: `LD_SINGLEFILE_OPTIONS=--user-agent="Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:124.0) Gecko/20100101 Firefox/124.0"`

### `LD_DISABLE_REQUEST_LOGS`

Values: `true` or `false` | Default =  `false`

Set uWSGI [disable-logging](https://uwsgi-docs.readthedocs.io/en/latest/Options.html#disable-logging) parameter to disable request logs, except for requests with a client (4xx) or server (5xx) error response.


================================================
FILE: docs/src/content/docs/search.md
================================================
---
title: Search
---

linkding provides a comprehensive search function for finding bookmarks. This guide gives on overview of the search capabilities and provides some examples.

## Search Expressions

Every search query is made up of one or more expressions. An expression can be a single word, a phrase, a tag, or a combination of these using boolean operators. The table below summarizes the different expression types:

| Expression   | Example                            | Description                                                |
|--------------|------------------------------------|------------------------------------------------------------|
| Word         | `history`                          | Search for a single word in title, description, notes, URL |
| Phrase       | `"history of rome"`                | Search for an exact phrase by enclosing it in quotes       |
| Tag          | `#book`                            | Search for a tag                                           |
| AND operator | `#history and #book`               | Both expressions must match                                |
| OR operator  | `#book or #article`                | Either expression must match                               |
| NOT operator | `not #article`                     | Expression must not match                                  |
| Grouping     | `#history and (#book or #article)` | Control evaluation order using parenthesis                 |

When combining multiple words, phrases or tags without an explicit operator, the `and` operator is assumed. For example:
```
history rome #book
```
is equivalent to:
```
history and rome and #book
```

Some additional rules to keep in mind:
- Words, phrases, tags, and operators are all case-insensitive.
- Tags must be prefixed with a `#` symbol. If the *lax* tag search mode is enabled in the settings, the `#` prefix is optional. In that case searching for a word will return both bookmarks containing that word or bookmarks tagged with that word.
- An operator (`and`, `or`, `not`) can not be used as a search term as such. To explicitly search for these words, use a phrase: `"beyond good and evil"`, `"good or bad"`, `"not found"`.

## Examples

Here are some example search queries and their meanings:

```
history rome #book
```
Search bookmarks that contain both "history" and "rome", and are tagged with "book".

```
"history of rome" #book
```
Search bookmarks that contain the exact phrase "history of rome" and are tagged with "book".

```
#article or #book
```
Search bookmarks that are tagged with either "article" or "book".

```
rome (#article or #book)
```
Search bookmarks that contain "rome" and are tagged with either "article" or "book".

```
history rome not #article
```
Search bookmarks that contain both "history" and "rome", but are not tagged with "article".

```
history rome not (#article or #book)
```
Search bookmarks that contain both "history" and "rome", but are not tagged with either "article" or "book".

## Legacy Search

A new search engine that supports the above expressions was introduced in linkding v1.44.0.
If you run into any issues with the new search, you can switch back to the old one by enabling legacy search in the settings.
Please report any issues you encounter with the new search on [GitHub](https://github.com/sissbruecker/linkding/issues) so they can be addressed.
This option will be removed in a future version.


================================================
FILE: docs/src/content/docs/shortcuts.md
================================================
---
title: "Keyboard Shortcuts"
description: "Keyboard Shortcuts"
---

The following keyboard shortcuts are currently available:

| Action                                                                                    | Shortcut                            |
|-------------------------------------------------------------------------------------------|-------------------------------------|
| Add new bookmark                                                                          | <kbd>n</kbd>                        |
| Focus search input                                                                        | <kbd>s</kbd>                        |
| Navigate bookmarks                                                                        | <kbd>↑</kbd>, <kbd>↓</kbd>          |
| Toggle bookmark notes                                                                     | <kbd>e</kbd>                        |


================================================
FILE: docs/src/content/docs/troubleshooting.md
================================================
---
title: "Troubleshooting"
description: "Common issues and solutions"
---

## Login fails with `403 CSRF verfication failed`

This can be the case when using a reverse proxy that rewrites the `Host` header, such as Nginx.
Since linkding version 1.15, the application includes a CSRF check that verifies that the `Origin` request header matches the `Host` header.
If the `Host` header is modified by the reverse proxy then this check fails.

To fix this, check the [reverse proxy setup documentation](/installation#reverse-proxy-setup) on how to configure header forwarding for your proxy server, or alternatively configure the  [`LD_CSRF_TRUSTED_ORIGINS` option](/options#ld_csrf_trusted_origins) to the URL from which you are accessing your linkding instance.

## Automatically detected title and description are incorrect

linkding automatically fetches the title and description of the web page from the metadata in the HTML `<head>`. By default, this happens on the server, which can return different results than what you see in your browser, for example, if a website uses JavaScript to dynamically change the title or description, or if a website requires login. Alternatively, both the browser extension and the bookmarklet can use the metadata directly from the page you are currently viewing in your browser. Note that for some websites this can give worse results, as not all websites correctly update the metadata in `<head>` while browsing the website (which is why fetching a fresh page on the server is still the default).

To use the title and description that you see in your browser:
- When using the linkding browser extension, enable the *Use browser metadata* option in the options of the extension.
- When adding the bookmarklet, the respective settings page allows you to choose whether to detect title and description from the server or in the browser.

## Archiving fails for certain websites

When using the server-based archiving feature (available in the `latest-plus` Docker image), you may encounter issues with certain websites where snapshots fail to capture the web page contents correctly.
Common issues include the website showing a bot detection page, a login screen, or some banner that blocks the content.
In rare cases taking a snapshot may also time out.

There are some options to mitigate these issues:
- To capture web page contents exactly as they appear in your browser, use the [Singlefile browser extension](/archiving#using-the-singlefile-browser-extension) or the [linkding browser extension](/archiving#using-the-linkding-browser-extension) with Singlefile integration.
- You can pass custom options to the SingleFile CLI, which linkding uses to capture web pages on the server, using the [`LD_SINGLEFILE_OPTIONS`](/options#ld_singlefile_options) environment variable. For example, changing the user agent might help with some bot detection systems.
- If snapshots are timing out, you can increase the timeout by setting the [`LD_SINGLEFILE_TIMEOUT_SEC`](/options#ld_singlefile_timeout_sec) environment variable to a higher value.

Check the [archiving documentation](/archiving) for more information on how to archive web pages with linkding.

## URL validation fails for seemingly valid URLs

When adding a bookmark, you may encounter URL validation errors even for URLs that seem valid and work in your browser. This is because linkding uses Django's URL validator, which has some limitations in what it considers a valid URL.

Common cases that may fail validation:
- Domains that contain an underscore
- URLs without a top-level domain
- URLs with a non-standard protocol (e.g. `chrome://`)

If you need to store URLs that don't pass the default validation, you can disable URL validation completely by setting the `LD_DISABLE_URL_VALIDATION` option to `True`. See the [options documentation](/options#ld_disable_url_validation) for how to configure this setting.

Further info:
- https://github.com/sissbruecker/linkding/issues/206
- https://code.djangoproject.com/ticket/18517


================================================
FILE: docs/src/env.d.ts
================================================
/// <reference path="../.astro/types.d.ts" />
/// <reference types="astro/client" />


================================================
FILE: docs/src/styles/custom.css
================================================
:root {
    --sl-nav-gap: 0.8rem;

    --sl-text-xs: var(--sl-text-sm);
}

/* Colors (dark mode) */
:root,
::backdrop {
    --sl-color-accent: hsl(241, 75%, 64%);
    --sl-color-text-accent: hsl(241, 90%, 82%);
}

/* Colors (light mode) */
:root[data-theme='light'],
[data-theme='light'] ::backdrop {
    --sl-color-accent: hsl(241, 63%, 59%);
    --sl-color-text-accent: hsl(241, 63%, 55%);
}

/* Align site search */
.header .title-wrapper + div.sl-flex {
    justify-content: flex-end;
}

/* Site title */
.site-title img {
    height: 36px;
}

/* Social icon size */
.social-icons svg {
    width: 20px;
    height: 20px;
}

/* Index page */
[data-has-hero] header {
    background: transparent;
    border-bottom: solid 1px transparent;
    -webkit-backdrop-filter: blur(10px);
    backdrop-filter: blur(10px);
}

[data-has-hero] .page {
    --hero-gradient: hsla(241, 63%, 59%, 0.2);
    background: linear-gradient(205deg, var(--hero-gradient), transparent 30%);
}

[data-has-hero][data-theme="dark"] .page {
    --hero-gradient: hsla(241, 63%, 59%, 0.25);
}

[data-has-hero] .hero {
    padding-bottom: 1rem;
}

[data-has-hero] .hero-image img {
    width: 100%;
    border: solid 1px var(--sl-color-gray-5);
    border-radius: .4rem;
    box-shadow: var(--sl-shadow-lg);
}

[data-has-hero] .hero-image.dark img {
    box-shadow: none;
}

[data-has-hero][data-theme="dark"] .hero-image.light {
    display: none;
}

[data-has-hero][data-theme="light"] .hero-image.dark {
    display: none;
}

[data-has-hero] h2 {
    margin-top: 3rem;
}

[data-has-hero] .card-grid {
    margin-top: 2rem !important;
}

@media (min-width: 50rem) {
    [data-has-hero] .page {
        --hero-gradient: hsla(241, 63%, 59%, 0.2);
        background: linear-gradient(205deg, var(--hero-gradient), transparent 50%);
    }

    [data-has-hero] .hero {
        padding-bottom: 4rem;
    }

    [data-has-hero] h2 {
        margin-top: 6rem !important;
    }

    [data-has-hero] .card-grid {
        margin-top: 3rem !important;
        gap: 3rem;
    }
}

================================================
FILE: docs/tsconfig.json
================================================
{
  "extends": "astro/tsconfigs/strict"
}

================================================
FILE: install-linkding.sh
================================================
#!/usr/bin/env bash

# Script for creating or updating a linkding installation / Docker container
# The script uses a number of variables that control how the container is set up
# and where the application data is stored on the host
# The following variables are available:
#
# LD_CONTAINER_NAME - name of the Docker container that should be created or updated
# LD_HOST_PORT - port on your system that the application will use
# LD_HOST_DATA_DIR - directory on your system where the applications database will be stored
#
# Variables can be from your shell like this:
# export LD_HOST_DATA_DIR=/etc/linkding/data

# Provide default variable values
if [ -z "${LD_CONTAINER_NAME}" ]; then
    LD_CONTAINER_NAME="linkding"
fi
if [ -z "${LD_HOST_PORT}" ]; then
    LD_HOST_PORT=9090
fi
if [ -z "${LD_HOST_DATA_DIR}" ]; then
    LD_HOST_DATA_DIR=/etc/linkding/data
fi

echo "Create or update linkding container"
echo "Container name: ${LD_CONTAINER_NAME}"
echo "Host port: ${LD_HOST_PORT}"
echo "Host data dir: ${LD_HOST_DATA_DIR}"

echo "Stop existing container..."
docker stop ${LD_CONTAINER_NAME} || true
echo "Remove existing container..."
docker rm ${LD_CONTAINER_NAME} || true
echo "Update image..."
docker pull sissbruecker/linkding:latest
echo "Start container..."
docker run -d \
  -p ${LD_HOST_PORT}:9090 \
  --name ${LD_CONTAINER_NAME} \
  -v ${LD_HOST_DATA_DIR}:/etc/linkding/data \
  sissbruecker/linkding:latest
echo "Done!"


================================================
FILE: manage.py
================================================
#!/usr/bin/env python
"""Django's command-line utility for administrative tasks."""
import os
import sys


def main():
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "bookmarks.settings")
    try:
        from django.core.management import execute_from_command_line
    except ImportError as exc:
        raise ImportError(
            "Couldn't import Django. Are you sure it's installed and "
            "available on your PYTHONPATH environment variable? Did you "
            "forget to activate a virtual environment?"
        ) from exc
    execute_from_command_line(sys.argv)


if __name__ == "__main__":
    main()


================================================
FILE: package.json
================================================
{
  "name": "linkding",
  "scripts": {
    "build": "npm run build-js && npm run build-theme-light && npm run build-theme-dark",
    "build-js": "rollup -c",
    "build-theme-light": "postcss -o bookmarks/static/theme-light.css bookmarks/styles/theme-light.css",
    "build-theme-dark": "postcss -o bookmarks/static/theme-dark.css bookmarks/styles/theme-dark.css",
    "dev": "rollup -c -w"
  },
  "dependencies": {
    "@floating-ui/dom": "^1.7.4",
    "@hotwired/turbo": "^8.0.6",
    "@rollup/plugin-node-resolve": "^16.0.1",
    "@rollup/plugin-terser": "^0.4.4",
    "@rollup/wasm-node": "^4.13.0",
    "cssnano": "^7.0.6",
    "lit": "^3.3.1",
    "postcss": "^8.4.45",
    "postcss-cli": "^11.0.0",
    "postcss-import": "^16.1.0",
    "postcss-nesting": "^13.0.0"
  },
  "devDependencies": {
    "prettier": "^3.3.3"
  },
  "web-types": "./web-types.json"
}


================================================
FILE: postcss.config.js
================================================
const cssnano = require("cssnano");
const postcssImport = require("postcss-import");
const postcssNesting = require("postcss-nesting");

module.exports = {
  plugins: [
    postcssImport,
    postcssNesting,
    cssnano({
      preset: "default",
    }),
  ],
};


================================================
FILE: pyproject.toml
================================================
[project]
name = "linkding"
version = "1.45.0"
description = "Self-hosted bookmark manager that is designed be to be minimal, fast, and easy to set up using Docker."
readme = "README.md"
requires-python = ">=3.13"
dependencies = [
    "beautifulsoup4>=4.14.3",
    "bleach>=6.3.0",
    "bleach-allowlist>=1.0.3",
    "django>=6.0",
    "djangorestframework>=3.16.1",
    "huey>=2.5.5",
    "markdown>=3.10",
    "mozilla-django-oidc>=5.0.2",
    "requests>=2.32.5",
    "supervisor>=4.3.0",
    "uwsgi>=2.0.31",
    "waybackpy>=3.0.6",
]

[dependency-groups]
dev = [
    "coverage>=7.13.1",
    "django-debug-toolbar>=6.1.0",
    "djlint>=1.36.4",
    "playwright>=1.57.0",
    "psycopg[binary]>=3.2.9",
    "pytest>=9.0.2",
    "pytest-django>=4.11.1",
    "pytest-xdist>=3.8.0",
    "ruff>=0.14.10",
]
# For PostgreSQL support, use the binary release for development so that not
# everyone needs to build from source. For production, use a separate dependency
# group that builds the driver from source. uv also needs to build it from
# source to update the lockfile, which requires libpq. On macOS:
# - brew install libpq
# - export PATH="/opt/homebrew/opt/libpq/bin:$PATH"
# - uv add --group postgres psycopg[c]
postgres = [
    "psycopg[c]>=3.2.9",
]

[tool.uv]
# Prefer system Python for now, less complications when copying the venv in the Docker build
python-preference = "system"

[tool.djlint]
custom_html="ld-\\w+,ld-\\w+-\\w+"
custom_blocks="formhelp"
indent=2
format_js=true
profile="django"

[tool.djlint.js]
indent_size=2

[tool.ruff.lint]
select = [
    # pycodestyle
    "E",
    # Pyflakes
    "F",
    # pyupgrade
    "UP",
    # flake8-bugbear
    "B",
    # flake8-simplify
    "SIM",
    # isort
    "I",
]
# ignore line length violations
ignore = ["E501"]


================================================
FILE: pytest.ini
================================================
[pytest]
DJANGO_SETTINGS_MODULE = bookmarks.settings.dev
# -- recommended but optional:
python_files = tests.py test_*.py *_tests.py


================================================
FILE: rollup.config.mjs
================================================
import resolve from '@rollup/plugin-node-resolve';
import terser from '@rollup/plugin-terser';

const production = !process.env.ROLLUP_WATCH;

// Custom plugin to exclude dev-tool.js from production builds
const excludeDevTool = {
  name: 'exclude-dev-tool',
  load(id) {
    if (production && id.endsWith('dev-tool.js')) {
      return '';
    }
    return null;
  },
};

export default {
  input: 'bookmarks/frontend/index.js',
  output: {
    sourcemap: true,
    format: 'iife',
    name: 'linkding',
    // Generate bundle in static folder to that it is picked up by Django static files finder
    file: 'bookmarks/static/bundle.js',
  },
  plugins: [
    excludeDevTool,
    // If you have external dependencies installed from
    // npm, you'll most likely need these plugins. In
    // some cases you'll need additional configuration —
    // consult the documentation for details:
    // https://github.com/rollup/rollup-plugin-commonjs
    resolve({
      browser: true,
    }),

    // If we're building for production (npm run build
    // instead of npm run dev), minify
    production && terser(),
  ],
  watch: {
    clearScreen: false,
  },
};


================================================
FILE: scripts/build-docker.sh
================================================
#!/usr/bin/env bash

version=$(<version.txt)

# Base image
docker buildx build --target linkding --platform linux/amd64,linux/arm64,linux/arm/v7 \
  -f docker/default.Dockerfile \
  -t sissbruecker/linkding:latest \
  -t sissbruecker/linkding:$version \
  --push .

docker buildx build --target linkding --platform linux/amd64,linux/arm64,linux/arm/v7 \
  -f docker/alpine.Dockerfile \
  -t sissbruecker/linkding:latest-alpine \
  -t sissbruecker/linkding:$version-alpine \
  --push .

# Plus image with support for single-file snapshots
# Needs checking if this works with ARMv7, excluded for now
docker buildx build --target linkding-plus --platform linux/amd64,linux/arm64 \
  -f docker/default.Dockerfile \
  -t sissbruecker/linkding:latest-plus \
  -t sissbruecker/linkding:$version-plus \
  --push .

docker buildx build --target linkding-plus --platform linux/amd64,linux/arm64 \
  -f docker/alpine.Dockerfile \
  -t sissbruecker/linkding:latest-plus-alpine \
  -t sissbruecker/linkding:$version-plus-alpine \
  --push .


================================================
FILE: scripts/coverage.sh
================================================
#!/usr/bin/env bash

uv run coverage erase
uv run coverage run manage.py test
uv run coverage report --sort=cover


================================================
FILE: scripts/generate-changelog.py
================================================
#!/usr/bin/env python3
from datetime import datetime

import requests


def load_releases_page(page):
    url = f'https://api.github.com/repos/sissbruecker/linkding/releases?page={page}'
    return requests.get(url).json()


def load_all_releases():
    load_next_page = True
    page = 1
    releases = []

    while load_next_page:
        page_result = load_releases_page(page)
        releases = releases + page_result
        load_next_page = len(page_result) > 0
        page = page + 1

    return releases


def render_release_section(release):
    date = datetime.fromisoformat(release['published_at'].replace("Z", "+00:00"))
    formatted_date = date.strftime('%d/%m/%Y')
    section = f'## {release["name"]} ({formatted_date})\n\n'
    body = release['body']
    # increase heading for body content
    body = body.replace("## What's Changed", "### What's Changed")
    body = body.replace("## New Contributors", "### New Contributors")
    section += body.strip()
    return section


def generate_change_log():
    releases = load_all_releases()

    change_log = '# Changelog\n\n'
    sections = [render_release_section(release) for release in releases]
    body = '\n\n---\n\n'.join(sections)
    change_log = change_log + body

    with open("CHANGELOG.md", "w") as file:
        file.write(change_log)


generate_change_log()


================================================
FILE: scripts/release.sh
================================================
#!/usr/bin/env bash

version=$(<version.txt)

git push origin master
git tag v${version}
git push origin v${version}
# ./scripts/build-docker.sh

echo "Done ✅"


================================================
FILE: scripts/run-docker.sh
================================================
#!/usr/bin/env bash

variant="${1:-default}"

docker build -f "docker/$variant.Dockerfile" --target linkding -t sissbruecker/linkding:local .

docker rm -f linkding-local || true

docker run --name linkding-local --rm -p 9090:9090  \
  -e LD_SUPERUSER_NAME=admin \
  -e LD_SUPERUSER_PASSWORD=admin \
  -e LD_SUPERVISOR_MANAGED=True \
  sissbruecker/linkding:local


================================================
FILE: scripts/run-postgres.sh
================================================
#!/usr/bin/env bash

# Remove previous container if exists
docker rm -f linkding-postgres-test || true

# Run postgres container
docker run -d \
  -e POSTGRES_DB=linkding \
  -e POSTGRES_USER=linkding \
  -e POSTGRES_PASSWORD=linkding \
  -p 5432:5432 \
  -v $(pwd)/tmp/postgres-data:/var/lib/postgresql/data \
  --name linkding-postgres-test \
  postgres

# Wait until postgres has started
echo >&2 "$(date +%Y%m%dt%H%M%S) Waiting for postgres container"
sleep 15

# Start linkding dev server
export LD_DB_ENGINE=postgres
export LD_DB_USER=linkding
export LD_DB_PASSWORD=linkding

export LD_SUPERUSER_NAME=admin
export LD_SUPERUSER_PASSWORD=admin

uv run manage.py migrate
uv run manage.py create_initial_superuser
uv run manage.py runserver


================================================
FILE: scripts/setup-ublock.sh
================================================
rm -rf uBOLite.chromium.mv3

# Download uBlock Origin Lite
TAG=$(curl -sL https://api.github.com/repos/uBlockOrigin/uBOL-home/releases/latest | jq -r '.tag_name')
DOWNLOAD_URL=https://github.com/uBlockOrigin/uBOL-home/releases/download/$TAG/uBOLite_$TAG.chromium.zip
echo "Downloading $DOWNLOAD_URL"
curl -L -o uBOLite.zip $DOWNLOAD_URL
unzip uBOLite.zip -d uBOLite.chromium.mv3
rm uBOLite.zip

# Enable annoyances rulesets in manifest.json
jq '.declarative_net_request.rule_resources |= map(if .id == "annoyances-overlays" or .id == "annoyances-cookies" or .id == "annoyances-social" or .id == "annoyances-widgets" or .id == "annoyances-others" then .enabled = true else . end)' uBOLite.chromium.mv3/manifest.json > temp.json
mv temp.json uBOLite.chromium.mv3/manifest.json

mkdir -p chromium-profile


================================================
FILE: scripts/test-environments/authelia-oidc/authelia/configuration.yml
================================================
---
###############################################################
#                   Authelia configuration                    #
###############################################################

server:
  address: 'tcp://:9091'

log:
  level: 'debug'

totp:
  issuer: 'authelia.com'

identity_validation:
  reset_password:
    jwt_secret: 'a_very_important_secret'

authentication_backend:
  file:
    path: '/config/users_database.yml'

access_control:
  default_policy: 'deny'
  rules:
    - domain: 'traefik.example.com'
      policy: 'one_factor'
    - domain: 'linkding.example.com'
      policy: 'one_factor'

session:
  secret: 'insecure_session_secret'

  cookies:
    - name: 'authelia_session'
      domain: 'example.com'  # Should match whatever your root protected domain is
      authelia_url: 'https://authelia.example.com'
      expiration: '1 hour'  # 1 hour
      inactivity: '5 minutes'  # 5 minutes
      default_redirection_url: 'https://linkding.example.com'

regulation:
  max_retries: 3
  find_time: '2 minutes'
  ban_time: '5 minutes'

storage:
  encryption_key: 'you_must_generate_a_random_string_of_more_than_twenty_chars_and_configure_this'
  local:
    path: '/config/db.sqlite3'

notifier:
  filesystem:
    filename: '/tmp/notification.txt'

identity_providers:
  oidc:
    ## The other portions of the mandatory OpenID Connect 1.0 configuration go here.
    ## See: https://www.authelia.com/c/oidc
    hmac_secret: 'this_is_a_secret_abc123abc123abc'
    jwks:
      - key_id: 'example'
        algorithm: 'RS256'
        use: 'sig'
        key: |
          -----BEGIN PRIVATE KEY-----
          MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCuS2pK2VzqW+Sn
          hBATps7vo2AdZCtF3p+FOJ4WEwQoiJarS0pAJxKn4BT9PHP1gY8XCs45Qys586xQ
          UZwS1/9B482tQwkDQkfqXOIfTzqhTydVsi6t8Ff7ywW8K2lURcK+PnSE91Yp8tSO
          YWlXDajoI8wKkRSpcCApkmBZ3hJiJR9DlcfwKBJSNxt+DbuobQs4SOpjSY4fnDpn
          S5DFc72hiFOxvdx48y8c08UU+zNyHIIjYQ1995HwXysn7UwWCJaC4lI4ecaxHa01
          4irOx3HsuXEzs/U5UBs2lBXFfKn/JHAPVJvxlER5ciUCNiHGWWh+A7hrd9BemoMQ
          kRCIlldJAgMBAAECggEACtSWGmhTFx+Gb/fbeWMjRv4RkAX8T+NHaZN09FVya9Pf
          ++0p5B5hcQPSPhGqeXoXYoTJ/4IqXpejEJsfngakvosJqe9pURXmatxiczRcxe8J
          mFBCCQ4vI27wUGroqMNMeH6gRi5p4OGtXlsUfQO06BboXAw7mtNENl0ZhmAPp6BB
          ZWyQm90Kwx4T0JgNwdlau+9ZWQ/10/7mOs1bX+8vZDFCmzbzFfoPjgEo+Mw1sE/H
          i5kQxWErkWfeiabVp/7JlazHSYygwk21t1VgSBP4tgfkdAht68BievwguxCIrFRG
          MPCkgzktJgIfo5k0yuo//afKUKo+OViQ3ZB4YdGKkQKBgQDPgl59fqRZpGCwnKPu
          ymVi2c/bxjm6aK2VLX2dUFrPprzmfvUY8j/jDDcx4zOJg7jxNs2PGDooLDOSwa82
          i+YPTnBHlS3PBUp7jLPdCcZ0I8gMT5OWxnmPwGqUS6BqVTAhDq3QsJxD88FS8eD2
          mbFuBh5WAhj9URX+vc/FwLO/+QKBgQDXBhOXNAB64goQOM7ymUxihLQtYemO9h5N
          /cXsxpJF8KH/PtWpw9c6nc2d/GPs4OYoCaqsuQVSyQXDcXayNC6Dn8KwUrJP2yGL
          CHOAGg6HJbq+c5AKE1ytzvblTCyOcHZCjtlqwqJwO68xTWfSdbkvYYnfwyx+g0O9
          SsoouvzF0QKBgHI2GBnMZVrtbUZnwJbCkVD5/zzAeq+Nw9RyqEu4mXLnG9tljzM+
          ykkGRS7RFWGfvWAOQM98jy3jPjONJQnJsENGcegERKVIDTm5NJn5MmBj/UxBVENN
          VET5q++ZPF6qKoZXVPWi7y87b3Fereosp4qeFX5TQzvRsGB4Sm5WZNjJAoGAbezN
          Vx9en3OvcVuZcKyuQC9XbVwA6vUnyPdTmBhr7xV1u+eDk6ZrAaxq0bmV3COdhhpr
          BqIP9qKOL7xx0eibXu7tuPaN8gU0wL8xTOwFQVIohfTOTlhXqQOFdPPcU3Vq/9vH
          iqy2Hmpkxe+shAtrAK38rkg5FvRETSFO+EOftgECgYEAi7nAy4ta2X5hHqt+86Rr
          OD1M1zdhreF73WvSBIeKiR+rffbgBvIRNFkGk4iYs6Wc6ZyoS+FEJGjO33Om+I1s
          Emd8JSHhRcRBq6cOsDzo4PKzMVSJaWpAfmCk9wVjAz0gpJDn2MtSanTqn1749A3L
          VU7Fiz0jxshSPqw2KIjcnBI=
          -----END PRIVATE KEY-----
        certificate_chain: |
          -----BEGIN CERTIFICATE-----
          MIIDIzCCAgugAwIBAgIQBDUsQ9wfCEtzppdn5GlKUDANBgkqhkiG9w0BAQsFADAy
          MREwDwYDVQQKEwhBdXRoZWxpYTEdMBsGA1UEAxMUYXV0aGVsaWEuZXhhbXBsZS5j
          b20wHhcNMjUwODIzMTEwOTM2WhcNMjYwODIzMTEwOTM2WjAyMREwDwYDVQQKEwhB
          dXRoZWxpYTEdMBsGA1UEAxMUYXV0aGVsaWEuZXhhbXBsZS5jb20wggEiMA0GCSqG
          SIb3DQEBAQUAA4IBDwAwggEKAoIBAQCuS2pK2VzqW+SnhBATps7vo2AdZCtF3p+F
          OJ4WEwQoiJarS0pAJxKn4BT9PHP1gY8XCs45Qys586xQUZwS1/9B482tQwkDQkfq
          XOIfTzqhTydVsi6t8Ff7ywW8K2lURcK+PnSE91Yp8tSOYWlXDajoI8wKkRSpcCAp
          kmBZ3hJiJR9DlcfwKBJSNxt+DbuobQs4SOpjSY4fnDpnS5DFc72hiFOxvdx48y8c
          08UU+zNyHIIjYQ1995HwXysn7UwWCJaC4lI4ecaxHa014irOx3HsuXEzs/U5UBs2
          lBXFfKn/JHAPVJvxlER5ciUCNiHGWWh+A7hrd9BemoMQkRCIlldJAgMBAAGjNTAz
          MA4GA1UdDwEB/wQEAwIFoDATBgNVHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8E
          AjAAMA0GCSqGSIb3DQEBCwUAA4IBAQAb910zH+0Yqxxq+LgJiIFC5guJAorY9WlD
          nRHvt/1i+ZvNdc57Xq6W5/YI1g5IG/EWyDOSr5mkw6VWvGrN/HTE7cH9d2LPyWxb
          n5dyUezUMdoXmizANJq7ixQLLSJiRFRhYGjiMK816m9zY/3KZqacpTJDsrhM2i6d
          aaGgfkxpivMDb4PEZs4dDlR5PfFuEBFWpTDBdUeWEx/sL3t1Zfogr6lKb8PmmnEI
          RKzofXAvAPQ69hE3jSWSldxqgE0Jofzwiw4dcLLAHmLlJDkbB+2HMJljFW9Fj7fK
          DW7HwcVQqJ4GOW/1IjuogZuDQUlXZPMI3iujoOhYOypx6Wpf4LzO
          -----END CERTIFICATE-----
    clients:
      - client_id: 'linkding'
        client_name: 'Linkding'
        client_secret: '$pbkdf2-sha512$310000$c8p78n7pUMln0jzvd4aK4Q$JNRBzwAo0ek5qKn50cFzzvE9RXV88h1wJn5KGiHrD0YKtZaR/nCb2CJPOsKaPK0hjf.9yHxzQGZziziccp6Yng'  # The digest of 'insecure_secret'.
        public: false
        authorization_policy: 'one_factor'
        require_pkce: false
        pkce_challenge_method: ''
        redirect_uris:
          - 'https://linkding.example.com/oidc/callback/'
        scopes:
          - 'openid'
          - 'email'
          - 'profile'
        access_token_signed_response_alg: 'none'
        userinfo_signed_response_alg: 'none'
        token_endpoint_auth_method: 'client_secret_post'
...


================================================
FILE: scripts/test-environments/authelia-oidc/authelia/users_database.yml
================================================
---
###############################################################
#                         Users Database                      #
###############################################################

# This file can be used if you do not have an LDAP set up.

# List of users
users:
  admin:
    disabled: false
    displayname: 'admin'
    password: '$argon2id$v=19$m=65536,t=3,p=4$t6SNxOtQ6wBnGZUbPu/MVQ$+KCk9Zfc7gemFDRo5a90yfbTkkR0dI5DbeNzYkKxXLE'
    email: 'admin@example.com'
    groups:
      - 'admins'
      - 'dev'
...


================================================
FILE: scripts/test-environments/authelia-oidc/compose.yml
================================================
# DO NOT USE THIS!
# This is only intended for testing OIDC functionality when developing Linkding.
# Follow the linkding and Authelia documentation to set up a proper production deployment.

networks:
  net:
    driver: 'bridge'

services:
  linkding:
    image: 'sissbruecker/linkding:local'
    environment:
      LD_SUPERUSER_NAME: 'admin'
      LD_SUPERUSER_PASSWORD: 'admin'
      LD_ENABLE_OIDC: 'True'
      OIDC_RP_CLIENT_ID: 'linkding'
      OIDC_RP_CLIENT_SECRET: 'insecure_secret'
      OIDC_OP_AUTHORIZATION_ENDPOINT: 'https://authelia.example.com/api/oidc/authorization'
      OIDC_OP_TOKEN_ENDPOINT: 'http://authelia:9091/api/oidc/token'
      OIDC_OP_USER_ENDPOINT: 'http://authelia:9091/api/oidc/userinfo'
      OIDC_OP_JWKS_ENDPOINT: 'http://authelia:9091/jwks.json'
    networks:
      net: {}
    labels:
      traefik.enable: 'true'
      traefik.http.routers.public.rule: 'Host(`linkding.example.com`)'
      traefik.http.routers.public.entrypoints: 'https'
      traefik.http.routers.public.tls: 'true'
      traefik.http.routers.public.tls.options: 'default'
  authelia:
    image: 'authelia/authelia:latest'
    volumes:
      - './authelia:/config'
    networks:
      net: {}
    labels:
      traefik.enable: 'true'
      traefik.http.routers.authelia.rule: 'Host(`authelia.example.com`)'
      traefik.http.routers.authelia.entrypoints: 'https'
      traefik.http.routers.authelia.tls: 'true'
      traefik.http.routers.authelia.tls.options: 'default'
  traefik:
    image: 'traefik:v3.5.0'
    volumes:
      - './traefik:/etc/traefik'
      - '/var/run/docker.sock:/var/run/docker.sock'
    networks:
      net: {}
    labels:
      traefik.enable: 'true'
      traefik.http.routers.api.rule: 'Host(`traefik.example.com`)'
      traefik.http.routers.api.entrypoints: 'https'
      traefik.http.routers.api.service: 'api@internal'
      traefik.http.routers.api.tls: 'true'
      traefik.http.routers.api.tls.options: 'default'
    ports:
      - '80:80/tcp'
      - '443:443/tcp'
      - '443:443/udp'
    command:
      - '--api'
      - '--providers.docker=true'
      - '--providers.docker.exposedByDefault=false'
      - '--providers.file.filename=/etc/traefik/certificates.yml'
      - '--entrypoints.http=true'
      - '--entrypoints.http.address=:80'
      - '--entrypoints.http.http.redirections.entrypoint.to=https'
      - '--entrypoints.http.http.redirections.entrypoint.scheme=https'
      - '--entrypoints.https=true'
      - '--entrypoints.https.address=:443'
      - '--log=true'
      - '--log.level=DEBUG'


================================================
FILE: scripts/test-environments/authelia-oidc/setup.sh
================================================
#!/usr/bin/env bash

writehosts(){
  echo "\
127.0.0.1  authelia.$DOMAIN
127.0.0.1  linkding.$DOMAIN
127.0.0.1  traefik.$DOMAIN" | sudo tee -a /etc/hosts > /dev/null
}

if [ $(id -u) != 0 ]; then
  echo "The script requires root access to perform some functions such as modifying your /etc/hosts file"
  read -rp "Would you like to elevate access with sudo? [y/N] " confirmsudo
  if ! [[ "$confirmsudo" =~ ^([yY][eE][sS]|[yY])$ ]]; then
    echo "Sudo elevation denied, exiting"
    exit 1
  fi
fi

DOMAIN="example.com"

MODIFIED=$(cat /etc/hosts | grep $DOMAIN && echo true || echo false)

if [[ $MODIFIED == "false" ]]; then
  writehosts
fi

sudo docker run -a stdout -v $PWD/traefik/certs:/tmp/certs authelia/authelia authelia crypto certificate rsa generate --common-name="*.${DOMAIN}" --directory=/tmp/certs/ > /dev/null
echo "Generated SSL certificate for *.$DOMAIN"

cat << EOF
Setup completed successfully.

You can start the stack with:
  docker compose up

You can then visit the following locations:
- https://linkding.$DOMAIN
- https://authelia.$DOMAIN
- https://traefik.$DOMAIN

You will need to authorize the self-signed certificate upon visiting each domain.
EOF


================================================
FILE: scripts/test-environments/authelia-oidc/traefik/certificates.yml
================================================
---
tls:
  certificates:
    - certFile: '/etc/traefik/certs/public.crt'
      keyFile: '/etc/traefik/certs/private.pem'
...


================================================
FILE: scripts/test-environments/postgres/compose.yml
================================================
# DO NOT USE THIS!
# This is only intended for testing PostgreSQL functionality when developing Linkding.
# Follow the linkding documentation to set up a proper production deployment.

services:
  postgres:
    image: 'postgres:16'
    environment:
      POSTGRES_DB: linkding
      POSTGRES_USER: linkding
      POSTGRES_PASSWORD: linkding
    healthcheck:
      test: ['CMD-SHELL', 'pg_isready -U linkding -d linkding']
      interval: 10s
      timeout: 5s
      retries: 5

  linkding:
    image: 'sissbruecker/linkding:local'
    environment:
      LD_SUPERUSER_NAME: 'admin'
      LD_SUPERUSER_PASSWORD: 'admin'
      LD_DB_ENGINE: 'postgres'
      LD_DB_HOST: 'postgres'
      LD_DB_PORT: '5432'
      LD_DB_DATABASE: 'linkding'
      LD_DB_USER: 'linkding'
      LD_DB_PASSWORD: 'linkding'
    ports:
      - '9090:9090'
    depends_on:
      postgres:
        condition: service_healthy

================================================
FILE: scripts/test-postgres.sh
================================================
#!/bin/bash

set -euo pipefail

# Remove previous container if exists
docker rm -f linkding-postgres-test || true

# Run postgres container
docker run -d \
  -e POSTGRES_DB=linkding \
  -e POSTGRES_USER=linkding \
  -e POSTGRES_PASSWORD=linkding \
  -p 5432:5432 \
  --name linkding-postgres-test \
  postgres

# Wait until postgres has started
echo >&2 "$(date +%Y%m%dt%H%M%S) Waiting for postgres container"
sleep 15

# Run tests using postgres
export LD_DB_ENGINE=postgres
export LD_DB_USER=linkding
export LD_DB_PASSWORD=linkding

make test
make e2e

# Remove postgres container
docker rm -f linkding-postgres-test || true


================================================
FILE: supervisord-all.conf
================================================
# Supervisor config that manages both uwsgi and background jobs
# Used when LD_SUPERVISOR_MANAGED is enabled, which also enables logging background tasks output to container logs
[supervisord]
user=root
nodaemon=true
loglevel=info

[program:uwsgi]
command=/bin/bash -c 'uwsgi --http ${LD_SERVER_HOST:-[::]}:${LD_SERVER_PORT:-9090} uwsgi.ini'
stdout_logfile=/dev/fd/1
stdout_logfile_maxbytes=0
stderr_logfile=/dev/fd/2
stderr_logfile_maxbytes=0
stopasgroup=true
autorestart=true

[program:jobs]
user=www-data
# setup a temp home folder for the job, required by chromium
environment=HOME=/tmp/home
command=python manage.py run_huey -f
stdout_logfile=/dev/fd/1
stdout_logfile_maxbytes=0
stderr_logfile=/dev/fd/2
stderr_logfile_maxbytes=0
stopasgroup=true
autorestart=true

[unix_http_server]
file=/var/run/supervisor.sock
chmod=0700

[rpcinterface:supervisor]
supervisor.rpcinterface_factory = supervisor.rpcinterface:make_main_rpcinterface

[supervisorctl]
serverurl=unix:///var/run/supervisor.sock


================================================
FILE: supervisord-tasks.conf
================================================
[supervisord]
user=root
loglevel=info

[program:jobs]
user=www-data
# setup a temp home folder for the job, required by chromium
environment=HOME=/tmp/home
command=python manage.py run_huey -f
stdout_logfile=background_tasks.log
stdout_logfile_maxbytes=10MB
stdout_logfile_backups=5
redirect_stderr=true

[unix_http_server]
file=/var/run/supervisor.sock
chmod=0700

[rpcinterface:supervisor]
supervisor.rpcinterface_factory = supervisor.rpcinterface:make_main_rpcinterface

[supervisorctl]
serverurl=unix:///var/run/supervisor.sock


================================================
FILE: uwsgi.ini
================================================
[uwsgi]
module = bookmarks.wsgi:application
env = DJANGO_SETTINGS_MODULE=bookmarks.settings.prod
static-map = /static=static
static-map = /static=data/favicons
static-map = /static=data/previews
static-map = /robots.txt=static/robots.txt
processes = 2
threads = 2
pidfile = /tmp/linkding.pid
vacuum=True
stats = 127.0.0.1:9191
uid = www-data
gid = www-data
buffer-size = 8192
die-on-term = true

if-env = LD_CONTEXT_PATH
static-map = /%(_)static=static
static-map = /%(_)static=data/favicons
static-map = /%(_)static=data/previews
static-map = /%(_)robots.txt=static/robots.txt
endif =

if-env = LD_REQUEST_TIMEOUT
http-timeout = %(_)
socket-timeout = %(_)
harakiri = %(_)
endif =

if-env = LD_REQUEST_MAX_CONTENT_LENGTH
limit-post = %(_)
endif =

if-env = LD_LOG_X_FORWARDED_FOR
log-x-forwarded-for = %(_)
endif =

if-env = LD_DISABLE_REQUEST_LOGS=true
disable-logging = true
log-4xx = true
log-5xx = true
endif =


================================================
FILE: version.txt
================================================
1.45.0