Bump version

* add support for auth proxies

* Improve docs

.env.sample

@@ -4,6 +4,9 @@ LD_CONTAINER_NAME=linkding
 LD_HOST_PORT=9090
 # Directory on the host system that should be mounted as data dir into the Docker container
 LD_HOST_DATA_DIR=./data
+# Can be used to run linkding under a context path, for example: linkding/
+# Must end with a slash `/`
+LD_CONTEXT_PATH=
 
 # Option to disable background tasks
 LD_DISABLE_BACKGROUND_TASKS=False

CHANGELOG.md

@@ -1,5 +1,54 @@
 # Changelog
 
+## 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

README.md

@@ -29,18 +29,19 @@ The name comes from:
 - ...so basically something for managing your links
 
 **Feature Overview:**
-- Tags for organizing bookmarks
-- Search by text or tags
+- Organize bookmarks with tags
+- Read it later functionality
+- Share bookmarks with other users
 - Bulk editing
 - Bookmark archive
-- Dark mode
-- Automatically creates snapshots of bookmarked websites on [the Internet Archive Wayback Machine](https://archive.org/web/)
 - Automatically provides titles and descriptions of bookmarked websites
+- Automatically creates snapshots of bookmarked websites on [the Internet Archive Wayback Machine](https://archive.org/web/)
 - Import and export bookmarks in Netscape HTML format
-- Extensions for [Firefox](https://addons.mozilla.org/de/firefox/addon/linkding-extension/) and [Chrome](https://chrome.google.com/webstore/detail/linkding-extension/beakmhbijpdhipnjhnclmhgjlddhidpe), and a bookmarklet that should work in most browsers
+- Extensions for [Firefox](https://addons.mozilla.org/de/firefox/addon/linkding-extension/) and [Chrome](https://chrome.google.com/webstore/detail/linkding-extension/beakmhbijpdhipnjhnclmhgjlddhidpe), as well as a bookmarklet
+- Light and dark themes
 - REST API for developing 3rd party apps
 - Admin panel for user self-service and raw data access
-- Easy to set up using Docker, uses SQLite as database
+- Easy setup using Docker, uses SQLite as database
 
 
 **Demo:** https://demo.linkding.link/ (configured with open registration)
@@ -126,10 +127,12 @@ The extension is open-source as well, and can be found [here](https://github.com
 This section lists community projects around using linkding, in alphabetical order. If you have a project that you want to share with the linkding community, feel free to submit a PR to add your project to this section.
 
 - [Helm Chart](https://charts.pascaliske.dev/charts/linkding/) Helm Chart for deploying linkding inside a Kubernetes cluster. By [pascaliske](https://github.com/pascaliske)
+- [Linka!](https://github.com/cmsax/linka) Web app (also a PWA) for quickly searching & opening bookmarks in linkding, support multi keywords, exclude mode and other advance options. By [cmsax](https://github.com/cmsax)
 - [linkding-extension](https://github.com/jeroenpardon/linkding-extension) Chromium compatible extension that wraps the linkding bookmarklet. Tested with Chrome, Edge, Brave. By [jeroenpardon](https://github.com/jeroenpardon)
 - [linkding-injector](https://github.com/Fivefold/linkding-injector) Injects search results from linkding into the sidebar of search pages like google and duckduckgo. Tested with Firefox and Chrome. By [Fivefold](https://github.com/Fivefold)
 - [aiolinkding](https://github.com/bachya/aiolinkding) A Python3, async library to interact with the linkding REST API. By [bachya](https://github.com/bachya)
 - [linkding-cli](https://github.com/bachya/linkding-cli) A command-line interface (CLI) to interact with the linkding REST API. Powered by [aiolinkding](https://github.com/bachya/aiolinkding). By [bachya](https://github.com/bachya)
+- [Open all links bookmarklet](https://gist.github.com/ukcuddlyguy/336dd7339e6d35fc64a75ccfc9323c66) A browser bookmarklet to open all links on the current Linkding page in new tabs. By [ukcuddlyguy](https://github.com/ukcuddlyguy)
 
 ## Development
 

bookmarks/admin.py

@@ -9,7 +9,7 @@ from django.utils.translation import ngettext, gettext
 from rest_framework.authtoken.admin import TokenAdmin
 from rest_framework.authtoken.models import TokenProxy
 
-from bookmarks.models import Bookmark, Tag, UserProfile, Toast
+from bookmarks.models import Bookmark, Tag, UserProfile, Toast, FeedToken
 from bookmarks.services.bookmarks import archive_bookmark, unarchive_bookmark
 
 
@@ -21,9 +21,9 @@ class LinkdingAdminSite(AdminSite):
 class AdminBookmark(admin.ModelAdmin):
     list_display = ('resolved_title', 'url', 'is_archived', 'owner', 'date_added')
     search_fields = ('title', 'description', 'website_title', 'website_description', 'url', 'tags__name')
-    list_filter = ('owner__username', 'is_archived', 'tags',)
+    list_filter = ('owner__username', 'is_archived', 'unread', 'tags',)
     ordering = ('-date_added',)
-    actions = ['archive_selected_bookmarks', 'unarchive_selected_bookmarks']
+    actions = ['archive_selected_bookmarks', 'unarchive_selected_bookmarks', 'mark_as_read', 'mark_as_unread']
 
     def archive_selected_bookmarks(self, request, queryset: QuerySet):
         for bookmark in queryset:
@@ -45,6 +45,24 @@ class AdminBookmark(admin.ModelAdmin):
             bookmarks_count,
         ) % bookmarks_count, messages.SUCCESS)
 
+    def mark_as_read(self, request, queryset: QuerySet):
+        bookmarks_count = queryset.count()
+        queryset.update(unread=False)
+        self.message_user(request, ngettext(
+            '%d bookmark marked as read.',
+            '%d bookmarks marked as read.',
+            bookmarks_count,
+        ) % bookmarks_count, messages.SUCCESS)
+
+    def mark_as_unread(self, request, queryset: QuerySet):
+        bookmarks_count = queryset.count()
+        queryset.update(unread=True)
+        self.message_user(request, ngettext(
+            '%d bookmark marked as unread.',
+            '%d bookmarks marked as unread.',
+            bookmarks_count,
+        ) % bookmarks_count, messages.SUCCESS)
+
 
 class AdminTag(admin.ModelAdmin):
     list_display = ('name', 'bookmarks_count', 'owner', 'date_added')
@@ -103,11 +121,18 @@ class AdminToast(admin.ModelAdmin):
     list_filter = ('owner__username',)
 
 
+class AdminFeedToken(admin.ModelAdmin):
+    list_display = ('key', 'user')
+    search_fields = ['key']
+    list_filter = ('user__username',)
+
+
 linkding_admin_site = LinkdingAdminSite()
 linkding_admin_site.register(Bookmark, AdminBookmark)
 linkding_admin_site.register(Tag, AdminTag)
 linkding_admin_site.register(User, AdminCustomUser)
 linkding_admin_site.register(TokenProxy, TokenAdmin)
 linkding_admin_site.register(Toast, AdminToast)
+linkding_admin_site.register(FeedToken, AdminFeedToken)
 linkding_admin_site.register(Task, TaskAdmin)
 linkding_admin_site.register(CompletedTask, CompletedTaskAdmin)

bookmarks/api/routes.py

@@ -6,7 +6,7 @@ from rest_framework.routers import DefaultRouter
 
 from bookmarks import queries
 from bookmarks.api.serializers import BookmarkSerializer, TagSerializer
-from bookmarks.models import Bookmark, Tag
+from bookmarks.models import Bookmark, BookmarkFilters, Tag, User
 from bookmarks.services.bookmarks import archive_bookmark, unarchive_bookmark
 from bookmarks.services.website_loader import load_website_metadata
 
@@ -42,6 +42,16 @@ class BookmarkViewSet(viewsets.GenericViewSet,
         data = serializer(page, many=True).data
         return self.get_paginated_response(data)
 
+    @action(methods=['get'], detail=False)
+    def shared(self, request):
+        filters = BookmarkFilters(request)
+        user = User.objects.filter(username=filters.user).first()
+        query_set = queries.query_shared_bookmarks(user, filters.query)
+        page = self.paginate_queryset(query_set)
+        serializer = self.get_serializer_class()
+        data = serializer(page, many=True).data
+        return self.get_paginated_response(data)
+
     @action(methods=['post'], detail=True)
     def archive(self, request, pk):
         bookmark = self.get_object()

bookmarks/api/serializers.py

@@ -20,6 +20,8 @@ class BookmarkSerializer(serializers.ModelSerializer):
             'website_title',
             'website_description',
             'is_archived',
+            'unread',
+            'shared',
             'tag_names',
             'date_added',
             'date_modified'
@@ -35,6 +37,8 @@ class BookmarkSerializer(serializers.ModelSerializer):
     title = serializers.CharField(required=False, allow_blank=True, default='')
     description = serializers.CharField(required=False, allow_blank=True, default='')
     is_archived = serializers.BooleanField(required=False, default=False)
+    unread = serializers.BooleanField(required=False, default=False)
+    shared = serializers.BooleanField(required=False, default=False)
     # Override readonly tag_names property to allow passing a list of tag names to create/update
     tag_names = TagListField(required=False, default=[])
 
@@ -44,12 +48,14 @@ class BookmarkSerializer(serializers.ModelSerializer):
         bookmark.title = validated_data['title']
         bookmark.description = validated_data['description']
         bookmark.is_archived = validated_data['is_archived']
+        bookmark.unread = validated_data['unread']
+        bookmark.shared = validated_data['shared']
         tag_string = build_tag_string(validated_data['tag_names'])
         return create_bookmark(bookmark, tag_string, self.context['user'])
 
     def update(self, instance: Bookmark, validated_data):
         # Update fields if they were provided in the payload
-        for key in ['url', 'title', 'description']:
+        for key in ['url', 'title', 'description', 'unread', 'shared']:
             if key in validated_data:
                 setattr(instance, key, validated_data[key])
 

bookmarks/components/SearchAutoComplete.svelte

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

bookmarks/components/api.js

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

bookmarks/feeds.py

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

bookmarks/middlewares.py

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

bookmarks/migrations/0014_alter_bookmark_unread.py

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

bookmarks/migrations/0015_feedtoken.py

@@ -0,0 +1,24 @@
+# Generated by Django 3.2.13 on 2022-07-23 20:35
+
+from django.conf import settings
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+        ('bookmarks', '0014_alter_bookmark_unread'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='FeedToken',
+            fields=[
+                ('key', models.CharField(max_length=40, primary_key=True, serialize=False)),
+                ('created', models.DateTimeField(auto_now_add=True)),
+                ('user', models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, related_name='feed_token', to=settings.AUTH_USER_MODEL)),
+            ],
+        ),
+    ]

bookmarks/migrations/0016_bookmark_shared.py

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

bookmarks/migrations/0017_userprofile_enable_sharing.py

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

bookmarks/models.py

@@ -1,8 +1,11 @@
+import binascii
+import os
 from typing import List
 
 from django import forms
 from django.contrib.auth import get_user_model
 from django.contrib.auth.models import User
+from django.core.handlers.wsgi import WSGIRequest
 from django.db import models
 from django.db.models.signals import post_save
 from django.dispatch import receiver
@@ -50,8 +53,9 @@ class Bookmark(models.Model):
     website_title = models.CharField(max_length=512, blank=True, null=True)
     website_description = models.TextField(blank=True, null=True)
     web_archive_snapshot_url = models.CharField(max_length=2048, blank=True)
-    unread = models.BooleanField(default=True)
+    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)
@@ -97,12 +101,35 @@ class BookmarkForm(forms.ModelForm):
                             required=False)
     description = forms.CharField(required=False,
                                   widget=forms.Textarea())
+    # Include website title and description as hidden field as they only provide info when editing bookmarks
+    website_title = forms.CharField(max_length=512,
+                                    required=False, widget=forms.HiddenInput())
+    website_description = forms.CharField(required=False,
+                                          widget=forms.HiddenInput())
+    unread = forms.BooleanField(required=False)
+    shared = forms.BooleanField(required=False)
     # Hidden field that determines whether to close window/tab after saving the bookmark
     auto_close = forms.CharField(required=False)
 
     class Meta:
         model = Bookmark
-        fields = ['url', 'tag_string', 'title', 'description', 'auto_close']
+        fields = [
+            'url',
+            'tag_string',
+            'title',
+            'description',
+            'website_title',
+            'website_description',
+            'unread',
+            'shared',
+            'auto_close',
+        ]
+
+
+class BookmarkFilters:
+    def __init__(self, request: WSGIRequest):
+        self.query = request.GET.get('q') or ''
+        self.user = request.GET.get('user') or ''
 
 
 class UserProfile(models.Model):
@@ -142,12 +169,13 @@ class UserProfile(models.Model):
                                             default=BOOKMARK_LINK_TARGET_BLANK)
     web_archive_integration = models.CharField(max_length=10, choices=WEB_ARCHIVE_INTEGRATION_CHOICES, blank=False,
                                                default=WEB_ARCHIVE_INTEGRATION_DISABLED)
+    enable_sharing = models.BooleanField(default=False, null=False)
 
 
 class UserProfileForm(forms.ModelForm):
     class Meta:
         model = UserProfile
-        fields = ['theme', 'bookmark_date_display', 'bookmark_link_target', 'web_archive_integration']
+        fields = ['theme', 'bookmark_date_display', 'bookmark_link_target', 'web_archive_integration', 'enable_sharing']
 
 
 @receiver(post_save, sender=get_user_model())
@@ -166,3 +194,27 @@ class Toast(models.Model):
     message = models.TextField()
     acknowledged = models.BooleanField(default=False)
     owner = models.ForeignKey(get_user_model(), on_delete=models.CASCADE)
+
+
+class FeedToken(models.Model):
+    """
+    Adapted from authtoken.models.Token
+    """
+    key = models.CharField(max_length=40, primary_key=True)
+    user = models.OneToOneField(get_user_model(),
+                                related_name='feed_token',
+                                on_delete=models.CASCADE,
+                                )
+    created = models.DateTimeField(auto_now_add=True)
+
+    def save(self, *args, **kwargs):
+        if not self.key:
+            self.key = self.generate_key()
+        return super().save(*args, **kwargs)
+
+    @classmethod
+    def generate_key(cls):
+        return binascii.hexlify(os.urandom(20)).decode()
+
+    def __str__(self):
+        return self.key

bookmarks/queries.py

@@ -1,3 +1,5 @@
+from typing import Optional
+
 from django.contrib.auth.models import User
 from django.db.models import Q, Count, Aggregate, CharField, Value, BooleanField, QuerySet
 
@@ -27,7 +29,13 @@ def query_archived_bookmarks(user: User, query_string: str) -> QuerySet:
         .filter(is_archived=True)
 
 
-def _base_bookmarks_query(user: User, query_string: str) -> QuerySet:
+def query_shared_bookmarks(user: Optional[User], query_string: str) -> QuerySet:
+    return _base_bookmarks_query(user, query_string) \
+        .filter(shared=True) \
+        .filter(owner__profile__enable_sharing=True)
+
+
+def _base_bookmarks_query(user: Optional[User], query_string: str) -> QuerySet:
     # Add aggregated tag info to bookmark instances
     query_set = Bookmark.objects \
         .annotate(tag_count=Count('tags'),
@@ -35,10 +43,11 @@ def _base_bookmarks_query(user: User, query_string: str) -> QuerySet:
                   tag_projection=Value(True, BooleanField()))
 
     # Filter for user
-    query_set = query_set.filter(owner=user)
+    if user:
+        query_set = query_set.filter(owner=user)
 
     # Split query into search terms and tags
-    query = _parse_query_string(query_string)
+    query = parse_query_string(query_string)
 
     # Filter for search terms and tags
     for term in query['search_terms']:
@@ -60,6 +69,11 @@ def _base_bookmarks_query(user: User, query_string: str) -> QuerySet:
         query_set = query_set.filter(
             tags=None
         )
+    # Unread bookmarks
+    if query['unread']:
+        query_set = query_set.filter(
+            unread=True
+        )
 
     # Sort by date added
     query_set = query_set.order_by('-date_added')
@@ -83,11 +97,27 @@ def query_archived_bookmark_tags(user: User, query_string: str) -> QuerySet:
     return query_set.distinct()
 
 
+def query_shared_bookmark_tags(user: Optional[User], query_string: str) -> QuerySet:
+    bookmarks_query = query_shared_bookmarks(user, query_string)
+
+    query_set = Tag.objects.filter(bookmark__in=bookmarks_query)
+
+    return query_set.distinct()
+
+
+def query_shared_bookmark_users(query_string: str) -> QuerySet:
+    bookmarks_query = query_shared_bookmarks(None, query_string)
+
+    query_set = User.objects.filter(bookmark__in=bookmarks_query)
+
+    return query_set.distinct()
+
+
 def get_user_tags(user: User):
     return Tag.objects.filter(owner=user).all()
 
 
-def _parse_query_string(query_string):
+def parse_query_string(query_string):
     # Sanitize query params
     if not query_string:
         query_string = ''
@@ -102,9 +132,11 @@ def _parse_query_string(query_string):
 
     # Special search commands
     untagged = '!untagged' in keywords
+    unread = '!unread' in keywords
 
     return {
         'search_terms': search_terms,
         'tag_names': tag_names,
         'untagged': untagged,
+        'unread': unread,
     }

bookmarks/services/bookmarks.py

@@ -5,7 +5,7 @@ from django.utils import timezone
 
 from bookmarks.models import Bookmark, parse_tag_string
 from bookmarks.services.tags import get_or_create_tags
-from bookmarks.services.website_loader import load_website_metadata
+from bookmarks.services import website_loader
 from bookmarks.services import tasks
 
 
@@ -38,16 +38,16 @@ def update_bookmark(bookmark: Bookmark, tag_string, current_user: User):
     # Detect URL change
     original_bookmark = Bookmark.objects.get(id=bookmark.id)
     has_url_changed = original_bookmark.url != bookmark.url
-    # Update website info
-    _update_website_metadata(bookmark)
     # Update tag list
     _update_bookmark_tags(bookmark, tag_string, current_user)
     # Update dates
     bookmark.date_modified = timezone.now()
     bookmark.save()
-    # Update web archive snapshot, if URL changed
     if has_url_changed:
+        # Update web archive snapshot, if URL changed
         tasks.create_web_archive_snapshot(current_user, bookmark, True)
+        # Only update website metadata if URL changed
+        _update_website_metadata(bookmark)
 
     return bookmark
 
@@ -116,10 +116,12 @@ def untag_bookmarks(bookmark_ids: [Union[int, str]], tag_string: str, current_us
 def _merge_bookmark_data(from_bookmark: Bookmark, to_bookmark: Bookmark):
     to_bookmark.title = from_bookmark.title
     to_bookmark.description = from_bookmark.description
+    to_bookmark.unread = from_bookmark.unread
+    to_bookmark.shared = from_bookmark.shared
 
 
 def _update_website_metadata(bookmark: Bookmark):
-    metadata = load_website_metadata(bookmark.url)
+    metadata = website_loader.load_website_metadata(bookmark.url)
     bookmark.website_title = metadata.title
     bookmark.website_description = metadata.description
 

bookmarks/services/importer.py

@@ -173,6 +173,7 @@ def _import_batch(netscape_bookmarks: List[NetscapeBookmark], user: User, tag_ca
             shortened_bookmark_tag_str = str(netscape_bookmark)[:100] + '...'
             logging.warning(
                 f'Failed to assign tags to the bookmark: {shortened_bookmark_tag_str}. Could not find bookmark by URL.')
+            continue
 
         # Get tag models by string, schedule inserts for bookmark -> tag associations
         tag_names = parse_tag_string(netscape_bookmark.tag_string)
@@ -191,7 +192,7 @@ def _copy_bookmark_data(netscape_bookmark: NetscapeBookmark, bookmark: Bookmark)
     else:
         bookmark.date_added = timezone.now()
     bookmark.date_modified = bookmark.date_added
-    bookmark.unread = False
+    bookmark.unread = netscape_bookmark.to_read
     if netscape_bookmark.title:
         bookmark.title = netscape_bookmark.title
     if netscape_bookmark.description:

bookmarks/services/parser.py

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

bookmarks/static/bookmark_list.js

@@ -0,0 +1,127 @@
+(function () {
+  function setupBulkEdit() {
+    const bulkEditToggle = document.getElementById('bulk-edit-mode')
+    const bulkEditBar = document.querySelector('.bulk-edit-bar')
+    const singleToggles = document.querySelectorAll('.bulk-edit-toggle input')
+    const allToggle = document.querySelector('.bulk-edit-all-toggle input')
+
+    function isAllSelected() {
+      let result = true
+
+      singleToggles.forEach(function (toggle) {
+        result = result && toggle.checked
+      })
+
+      return result
+    }
+
+    function selectAll() {
+      singleToggles.forEach(function (toggle) {
+        toggle.checked = true
+      })
+    }
+
+    function deselectAll() {
+      singleToggles.forEach(function (toggle) {
+        toggle.checked = false
+      })
+    }
+
+    // Toggle all
+    allToggle.addEventListener('change', function (e) {
+      if (e.target.checked) {
+        selectAll()
+      } else {
+        deselectAll()
+      }
+    })
+
+    // Toggle single
+    singleToggles.forEach(function (toggle) {
+      toggle.addEventListener('change', function () {
+        allToggle.checked = isAllSelected()
+      })
+    })
+
+    // Allow overflow when bulk edit mode is active to be able to display tag auto complete menu
+    let bulkEditToggleTimeout
+    if (bulkEditToggle.checked) {
+      bulkEditBar.style.overflow = 'visible';
+    }
+    bulkEditToggle.addEventListener('change', function (e) {
+      if (bulkEditToggleTimeout) {
+        clearTimeout(bulkEditToggleTimeout);
+        bulkEditToggleTimeout = null;
+      }
+      if (e.target.checked) {
+        bulkEditToggleTimeout = setTimeout(function () {
+          bulkEditBar.style.overflow = 'visible';
+        }, 500);
+      } else {
+        bulkEditBar.style.overflow = 'hidden';
+      }
+    });
+  }
+
+  function setupBulkEditTagAutoComplete() {
+    const wrapper = document.createElement('div');
+    const tagInput = document.getElementById('bulk-edit-tags-input');
+    const apiBaseUrl = document.documentElement.dataset.apiBaseUrl || '';
+    const apiClient = new linkding.ApiClient(apiBaseUrl)
+
+    new linkding.TagAutoComplete({
+      target: wrapper,
+      props: {
+        id: 'bulk-edit-tags-input',
+        name: tagInput.name,
+        value: tagInput.value,
+        apiClient: apiClient,
+        variant: 'small'
+      }
+    });
+
+    tagInput.parentElement.replaceChild(wrapper, tagInput);
+  }
+
+  function setupListNavigation() {
+    // Add logic for navigating bookmarks with arrow keys
+    document.addEventListener('keydown', event => {
+      // Skip if event occurred within an input element
+      // or does not use arrow keys
+      const targetNodeName = event.target.nodeName;
+      const isInputTarget = targetNodeName === 'INPUT'
+        || targetNodeName === 'SELECT'
+        || targetNodeName === 'TEXTAREA';
+      const isArrowUp = event.key === 'ArrowUp';
+      const isArrowDown = event.key === 'ArrowDown';
+
+      if (isInputTarget || !(isArrowUp || isArrowDown)) {
+        return;
+      }
+      event.preventDefault();
+
+      // Detect current bookmark list item
+      const path = event.composedPath();
+      const currentItem = path.find(item => item.hasAttribute && item.hasAttribute('data-is-bookmark-item'));
+
+      // Find next item
+      let nextItem;
+      if (currentItem) {
+        nextItem = isArrowUp
+          ? currentItem.previousElementSibling
+          : currentItem.nextElementSibling;
+      } else {
+        // Select first item
+        nextItem = document.querySelector('li[data-is-bookmark-item]');
+      }
+      // Focus first link
+      if (nextItem) {
+        nextItem.querySelector('a').focus();
+      }
+    });
+  }
+
+  setupBulkEdit();
+  setupBulkEditTagAutoComplete();
+  setupListNavigation();
+})()

bookmarks/static/bulk_edit.js

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

bookmarks/styles/bookmarks.scss

@@ -49,6 +49,15 @@ ul.bookmark-list {
   margin: 0;
   padding: 0;
 
+  .title a {
+    display: inline-block;
+    vertical-align: top;
+    width: 100%;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+  }
+
   .description {
     color: $gray-color-dark;
 
@@ -91,8 +100,18 @@ ul.bookmark-list {
 
 .tag-cloud {
 
-  a, a:visited:hover {
-    color: $alternative-color;
+  .selected-tags {
+    margin-bottom: 0.8rem;
+
+    a, a:visited:hover {
+      color: $error-color;
+    }
+  }
+
+  .unselected-tags {
+    a, a:visited:hover {
+      color: $alternative-color;
+    }
   }
 
   .group {

bookmarks/templates/bookmarks/archive.html

@@ -14,7 +14,7 @@
             <div class="content-area-header">
                 <h2>Archived bookmarks</h2>
                 <div class="spacer"></div>
-                {% bookmark_search query tags mode='archive' %}
+                {% bookmark_search filters tags mode='archived' %}
                 {% include 'bookmarks/bulk_edit/toggle.html' %}
             </div>
 
@@ -33,16 +33,14 @@
 
         {# Tag list #}
         <section class="content-area column col-4 hide-md">
-            <div class="content-area-header align-baseline">
+            <div class="content-area-header">
                 <h2>Tags</h2>
-                <div class="spacer"></div>
-                <a href="?q=!untagged" class="text-gray text-sm">Show Untagged</a>
             </div>
-            {% tag_cloud tags %}
+            {% tag_cloud tags selected_tags %}
         </section>
     </div>
 
     <script src="{% static "bundle.js" %}"></script>
     <script src="{% static "shared.js" %}"></script>
-    <script src="{% static "bulk_edit.js" %}"></script>
+    <script src="{% static "bookmark_list.js" %}"></script>
 {% endblock %}

bookmarks/templates/bookmarks/bookmark_list.html

@@ -8,14 +8,17 @@
                 <input type="checkbox" name="bookmark_id" value="{{ bookmark.id }}">
                 <i class="form-icon"></i>
             </label>
-            <div class="title truncate">
-                <a href="{{ bookmark.url }}" target="{{ link_target }}" rel="noopener">{{ bookmark.resolved_title }}</a>
+            <div class="title">
+                <a href="{{ bookmark.url }}" target="{{ link_target }}" rel="noopener"
+                   class="{% if bookmark.unread %}text-italic{% endif %}">
+                    {{ bookmark.resolved_title }}
+                </a>
             </div>
             <div class="description truncate">
                 {% if bookmark.tag_names %}
                     <span>
                             {% for tag_name in bookmark.tag_names %}
-                                <a href="?{% append_query_param q=tag_name|hash_tag %}">{{ tag_name|hash_tag }}</a>
+                                <a href="?{% append_to_query_param q=tag_name|hash_tag %}">{{ tag_name|hash_tag }}</a>
                             {% endfor %}
                         </span>
                 {% endif %}
@@ -54,17 +57,30 @@
                     </span>
                     <span class="text-gray text-sm">|</span>
                 {% endif %}
-                <a href="{% url 'bookmarks:edit' bookmark.id %}?return_url={{ return_url }}"
-                   class="btn btn-link btn-sm">Edit</a>
-                {% if bookmark.is_archived %}
-                    <button type="submit" name="unarchive" value="{{ bookmark.id }}"
-                       class="btn btn-link btn-sm">Unarchive</button>
+                {% if bookmark.owner == request.user %}
+                    {# Bookmark owner actions #}
+                    <a href="{% url 'bookmarks:edit' bookmark.id %}?return_url={{ return_url }}"
+                       class="btn btn-link btn-sm">Edit</a>
+                    {% if bookmark.is_archived %}
+                        <button type="submit" name="unarchive" value="{{ bookmark.id }}"
+                           class="btn btn-link btn-sm">Unarchive</button>
+                    {% else %}
+                        <button type="submit" name="archive" value="{{ bookmark.id }}"
+                           class="btn btn-link btn-sm">Archive</button>
+                    {% endif %}
+                    <button type="submit" name="remove" value="{{ bookmark.id }}"
+                       class="btn btn-link btn-sm btn-confirmation">Remove</button>
+                    {% if bookmark.unread %}
+                      <span class="text-gray text-sm">|</span>
+                      <button type="submit" name="mark_as_read" value="{{ bookmark.id }}"
+                              class="btn btn-link btn-sm">Mark as read</button>
+                    {% endif %}
                 {% else %}
-                    <button type="submit" name="archive" value="{{ bookmark.id }}"
-                       class="btn btn-link btn-sm">Archive</button>
+                    {# Shared bookmark actions #}
+                    <span class="text-gray text-sm">Shared by
+                      <a class="text-gray" href="?{% replace_query_param user=bookmark.owner.username %}">{{ bookmark.owner.username }}</a>
+                    </span>
                 {% endif %}
-                <button type="submit" name="remove" value="{{ bookmark.id }}"
-                   class="btn btn-link btn-sm btn-confirmation">Remove</button>
             </div>
         </li>
     {% endfor %}

bookmarks/templates/bookmarks/form.html

@@ -3,6 +3,8 @@
 
 <div class="bookmarks-form">
     {% csrf_token %}
+    {{ form.website_title }}
+    {{ form.website_description }}
     {{ form.auto_close|attr:"type:hidden" }}
     <div class="form-group {% if form.url.errors %}has-error{% endif %}">
         <label for="{{ form.url.id_for_label }}" class="form-label">URL</label>
@@ -49,7 +51,7 @@
     <div class="form-group">
         <label for="{{ form.description.id_for_label }}" class="form-label">Description</label>
         <div class="has-icon-right">
-            {{ form.description|add_class:"form-input"|attr:"rows:4" }}
+            {{ form.description|add_class:"form-input"|attr:"rows:2" }}
             <i class="form-icon loading"></i>
             <a class="btn btn-link form-icon" title="Edit description from website">
                 <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20" fill="currentColor">
@@ -65,6 +67,28 @@
         </div>
         {{ form.description.errors }}
     </div>
+    <div class="form-group">
+      <label for="{{ form.unread.id_for_label }}" class="form-checkbox">
+        {{ form.unread }}
+        <i class="form-icon"></i>
+        <span>Mark as unread</span>
+      </label>
+      <div class="form-input-hint">
+        Unread bookmarks can be filtered for, and marked as read after you had a chance to look at them.
+      </div>
+    </div>
+    {% if request.user.profile.enable_sharing %}
+      <div class="form-group">
+        <label for="{{ form.shared.id_for_label }}" class="form-checkbox">
+          {{ form.shared }}
+          <i class="form-icon"></i>
+          <span>Share</span>
+        </label>
+        <div class="form-input-hint">
+          Share this bookmark with other users.
+        </div>
+      </div>
+    {% endif %}
     <br/>
     <div class="form-group">
         {% if auto_close %}
@@ -104,6 +128,8 @@
             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 websiteTitleInput = document.getElementById('{{ form.website_title.id_for_label }}');
+            const websiteDescriptionInput = document.getElementById('{{ form.website_description.id_for_label }}');
             const editedBookmarkId = {{ bookmark_id }};
 
             function toggleLoadingIcon(input, show) {
@@ -160,8 +186,19 @@
                 });
             }
 
-            if (urlInput.value) checkUrl();
+            // Fetch initial website data if we have a URL, and we are not editing an existing bookmark
+            // For existing bookmarks we get the website metadata through hidden inputs
+            if (urlInput.value && !editedBookmarkId) {
+              checkUrl();
+            }
             urlInput.addEventListener('input', checkUrl);
+
+            // Set initial website title and description for edited bookmarks
+            if (editedBookmarkId) {
+              updatePlaceholder(titleInput, websiteTitleInput.value);
+              updatePlaceholder(descriptionInput, websiteDescriptionInput.value);
+            }
+
             setupEditAutoValueButton(titleInput);
             setupEditAutoValueButton(descriptionInput);
         })();

bookmarks/templates/bookmarks/index.html

@@ -14,7 +14,7 @@
             <div class="content-area-header">
                 <h2>Bookmarks</h2>
                 <div class="spacer"></div>
-                {% bookmark_search query tags %}
+                {% bookmark_search filters tags %}
                 {% include 'bookmarks/bulk_edit/toggle.html' %}
             </div>
 
@@ -33,16 +33,14 @@
 
         {# Tag list #}
         <section class="content-area column col-4 hide-md">
-            <div class="content-area-header align-baseline">
+            <div class="content-area-header">
                 <h2>Tags</h2>
-                <div class="spacer"></div>
-                <a href="?q=!untagged" class="text-gray text-sm">Show Untagged</a>
             </div>
-            {% tag_cloud tags %}
+            {% tag_cloud tags selected_tags %}
         </section>
     </div>
 
     <script src="{% static "bundle.js" %}"></script>
     <script src="{% static "shared.js" %}"></script>
-    <script src="{% static "bulk_edit.js" %}"></script>
+    <script src="{% static "bookmark_list.js" %}"></script>
 {% endblock %}

bookmarks/templates/bookmarks/layout.html

@@ -44,7 +44,7 @@
     {% endif %}
     <div class="navbar container grid-lg">
         <section class="navbar-section">
-            <a href="/" class="navbar-brand text-bold">
+            <a href="{% url 'bookmarks:index' %}" class="navbar-brand text-bold">
                 <img class="logo" src="{% static 'logo.png' %}" alt="Application logo">
                 <h1>linkding</h1>
             </a>

bookmarks/templates/bookmarks/nav_menu.html

@@ -1,7 +1,33 @@
 {# Basic menu list #}
 <div class="hide-md">
     <a href="{% url 'bookmarks:new' %}" class="btn btn-primary mr-2">Add bookmark</a>
-    <a href="{% url 'bookmarks:archived' %}" class="btn btn-link">Archive</a>
+    <div class="dropdown">
+        <a href="#" class="btn btn-link dropdown-toggle" tabindex="0" style="padding-right: 0.2rem">
+          Bookmarks
+          <svg xmlns="http://www.w3.org/2000/svg" class="h-5 w-5" viewBox="0 0 20 20" fill="currentColor" style="height:1rem;width:1rem;vertical-align: text-bottom;">
+            <path fill-rule="evenodd" d="M5.293 7.293a1 1 0 011.414 0L10 10.586l3.293-3.293a1 1 0 111.414 1.414l-4 4a1 1 0 01-1.414 0l-4-4a1 1 0 010-1.414z" clip-rule="evenodd" />
+          </svg>
+        </a>
+        <ul class="menu">
+          <li>
+            <a href="{% url 'bookmarks:index' %}" class="btn btn-link">Active</a>
+          </li>
+          <li>
+            <a href="{% url 'bookmarks:archived' %}" class="btn btn-link">Archived</a>
+          </li>
+          {% if request.user.profile.enable_sharing %}
+          <li>
+            <a href="{% url 'bookmarks:shared' %}" class="btn btn-link">Shared</a>
+          </li>
+          {% endif %}
+          <li>
+            <a href="{% url 'bookmarks:index' %}?q=!unread" class="btn btn-link">Unread</a>
+          </li>
+          <li>
+            <a href="{% url 'bookmarks:index' %}?q=!untagged" class="btn btn-link">Untagged</a>
+          </li>
+        </ul>
+    </div>
     <a href="{% url 'bookmarks:settings.index' %}" class="btn btn-link">Settings</a>
     <a href="{% url 'logout' %}" class="btn btn-link">Logout</a>
 </div>
@@ -21,7 +47,21 @@
         <!-- menu component -->
         <ul class="menu">
             <li>
-                <a href="{% url 'bookmarks:archived' %}" class="btn btn-link">Archive</a>
+              <a href="{% url 'bookmarks:index' %}" class="btn btn-link">Bookmarks</a>
+            </li>
+            <li style="padding-left: 1rem">
+              <a href="{% url 'bookmarks:archived' %}" class="btn btn-link">Archived</a>
+            </li>
+            {% if request.user.profile.enable_sharing %}
+            <li style="padding-left: 1rem">
+              <a href="{% url 'bookmarks:shared' %}" class="btn btn-link">Shared</a>
+            </li>
+            {% endif %}
+            <li style="padding-left: 1rem">
+              <a href="{% url 'bookmarks:index' %}?q=!unread" class="btn btn-link">Unread</a>
+            </li>
+            <li style="padding-left: 1rem">
+              <a href="{% url 'bookmarks:index' %}?q=!untagged" class="btn btn-link">Untagged</a>
             </li>
             <li>
                 <a href="{% url 'bookmarks:settings.index' %}" class="btn btn-link">Settings</a>

bookmarks/templates/bookmarks/search.html

@@ -3,10 +3,13 @@
         <div class="input-group">
             <span id="search-input-wrap">
                 <input type="search" class="form-input" name="q" placeholder="Search for words or #tags"
-                       value="{{ query }}">
+                       value="{{ filters.query }}">
             </span>
             <input type="submit" value="Search" class="btn input-group-btn">
         </div>
+        {% if filters.user %}
+            <input type="hidden" name="user" value="{{ filters.user }}">
+        {% endif %}
     </form>
 </div>
 
@@ -15,6 +18,11 @@
     window.addEventListener("load", function() {
         const currentTagsString = '{{ tags_string }}';
         const currentTags = currentTagsString.split(' ');
+        const uniqueTags = [...new Set(currentTags)]
+        const filters = {
+          q: '{{ filters.query }}',
+          user: '{{ filters.user }}',
+        }
         const apiClient = new linkding.ApiClient('{% url 'bookmarks:api-root' %}')
         const wrapper = document.getElementById('search-input-wrap')
         const newWrapper = document.createElement('div')
@@ -23,10 +31,11 @@
             props: {
                 name: 'q',
                 placeholder: 'Search for words or #tags',
-                value: '{{ query }}',
-                tags: currentTags,
+                value: '{{ filters.query }}',
+                tags: uniqueTags,
                 mode: '{{ mode }}',
-                apiClient
+                apiClient,
+                filters,
             }
         })
         wrapper.parentElement.replaceChild(newWrapper, wrapper)

bookmarks/templates/bookmarks/shared.html

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

bookmarks/templates/bookmarks/tag_cloud.html

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

bookmarks/templates/bookmarks/user_select.html

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

bookmarks/templates/settings/general.html

@@ -47,6 +47,16 @@
                       case it goes offline or its content is modified.
                     </div>
                 </div>
+                <div class="form-group">
+                    <label for="{{ form.enable_sharing.id_for_label }}" class="form-checkbox">
+                      {{ form.enable_sharing }}
+                      <i class="form-icon"></i> Enable bookmark sharing
+                    </label>
+                    <div class="form-input-hint">
+                      Allows to share bookmarks with other users, and to view shared bookmarks.
+                      Disabling this feature will hide all previously shared bookmarks from other users.
+                    </div>
+                </div>
                 <div class="form-group">
                     <input type="submit" value="Save" class="btn btn-primary mt-2">
                 </div>

bookmarks/templates/settings/integrations.html

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

bookmarks/templatetags/bookmarks.py

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

bookmarks/templatetags/shared.py

@@ -17,7 +17,7 @@ def update_query_string(context, **kwargs):
 
 
 @register.simple_tag(takes_context=True)
-def append_query_param(context, **kwargs):
+def append_to_query_param(context, **kwargs):
     query = context.request.GET.copy()
 
     # Append to or create query param
@@ -32,6 +32,34 @@ def append_query_param(context, **kwargs):
     return query.urlencode()
 
 
+@register.simple_tag(takes_context=True)
+def remove_from_query_param(context, **kwargs):
+    query = context.request.GET.copy()
+
+    # Remove item from query param
+    for key in kwargs:
+        if query.__contains__(key):
+            value = query.__getitem__(key)
+            parts = value.split()
+            part_to_remove = kwargs[key]
+            updated_parts = [part for part in parts if str.lower(part) != str.lower(part_to_remove)]
+            updated_value = ' '.join(updated_parts)
+            query.__setitem__(key, updated_value)
+
+    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='hash_tag')
 def hash_tag(tag_name):
     return '#' + tag_name

bookmarks/tests/helpers.py

@@ -1,8 +1,8 @@
 import random
 import logging
-from dataclasses import dataclass
-from typing import Optional, List
+from typing import List
 
+from bs4 import BeautifulSoup
 from django.contrib.auth.models import User
 from django.utils import timezone
 from django.utils.crypto import get_random_string
@@ -23,6 +23,8 @@ class BookmarkFactoryMixin:
 
     def setup_bookmark(self,
                        is_archived: bool = False,
+                       unread: bool = False,
+                       shared: bool = False,
                        tags=None,
                        user: User = None,
                        url: str = '',
@@ -32,6 +34,8 @@ class BookmarkFactoryMixin:
                        website_description: str = '',
                        web_archive_snapshot_url: str = '',
                        ):
+        if not title:
+            title = get_random_string(length=32)
         if tags is None:
             tags = []
         if user is None:
@@ -49,6 +53,8 @@ class BookmarkFactoryMixin:
             date_modified=timezone.now(),
             owner=user,
             is_archived=is_archived,
+            unread=unread,
+            shared=shared,
             web_archive_snapshot_url=web_archive_snapshot_url,
         )
         bookmark.save()
@@ -66,6 +72,19 @@ class BookmarkFactoryMixin:
         tag.save()
         return tag
 
+    def setup_user(self, name: str = None, enable_sharing: bool = False):
+        if not name:
+            name = get_random_string(length=32)
+        user = User.objects.create_user(name, 'user@example.com', 'password123')
+        user.profile.enable_sharing = enable_sharing
+        user.profile.save()
+        return user
+
+
+class HtmlTestMixin:
+    def make_soup(self, html: str):
+        return BeautifulSoup(html, features="html.parser")
+
 
 class LinkdingApiTestCase(APITestCase):
     def get(self, url, expected_status_code=status.HTTP_200_OK):
@@ -95,12 +114,19 @@ class LinkdingApiTestCase(APITestCase):
 
 
 class BookmarkHtmlTag:
-    def __init__(self, href: str = '', title: str = '', description: str = '', add_date: str = '', tags: str = ''):
+    def __init__(self,
+                 href: str = '',
+                 title: str = '',
+                 description: str = '',
+                 add_date: str = '',
+                 tags: str = '',
+                 to_read: bool = False):
         self.href = href
         self.title = title
         self.description = description
         self.add_date = add_date
         self.tags = tags
+        self.to_read = to_read
 
 
 class ImportTestMixin:
@@ -109,7 +135,8 @@ class ImportTestMixin:
         <DT>
         <A {f'HREF="{tag.href}"' if tag.href else ''}
            {f'ADD_DATE="{tag.add_date}"' if tag.add_date else ''}
-           {f'TAGS="{tag.tags}"' if tag.tags else ''}>
+           {f'TAGS="{tag.tags}"' if tag.tags else ''}
+           TOREAD="{1 if tag.to_read else 0}">
            {tag.title if tag.title else ''}
         </A>
         {f'<DD>{tag.description}' if tag.description else ''}

bookmarks/tests/test_auth_proxy_support.py

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

bookmarks/tests/test_bookmark_action_view.py

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

bookmarks/tests/test_bookmark_archived_view.py

@@ -1,47 +1,60 @@
+from typing import List
+
 from django.contrib.auth.models import User
 from django.test import TestCase
 from django.urls import reverse
 
 from bookmarks.models import Bookmark, Tag, UserProfile
-from bookmarks.tests.helpers import BookmarkFactoryMixin
+from bookmarks.tests.helpers import BookmarkFactoryMixin, HtmlTestMixin
 
 
-class BookmarkArchivedViewTestCase(TestCase, BookmarkFactoryMixin):
+class BookmarkArchivedViewTestCase(TestCase, BookmarkFactoryMixin, HtmlTestMixin):
 
     def setUp(self) -> None:
         user = self.get_or_create_test_user()
         self.client.force_login(user)
 
-    def assertVisibleBookmarks(self, response, bookmarks: [Bookmark], link_target: str = '_blank'):
+    def assertVisibleBookmarks(self, response, bookmarks: List[Bookmark], link_target: str = '_blank'):
         html = response.content.decode()
         self.assertContains(response, 'data-is-bookmark-item', count=len(bookmarks))
 
         for bookmark in bookmarks:
             self.assertInHTML(
-                f'<a href="{bookmark.url}" target="{link_target}" rel="noopener">{bookmark.resolved_title}</a>',
+                f'<a href="{bookmark.url}" target="{link_target}" rel="noopener" class="">{bookmark.resolved_title}</a>',
                 html
             )
 
-    def assertInvisibleBookmarks(self, response, bookmarks: [Bookmark], link_target: str = '_blank'):
+    def assertInvisibleBookmarks(self, response, bookmarks: List[Bookmark], link_target: str = '_blank'):
         html = response.content.decode()
 
         for bookmark in bookmarks:
             self.assertInHTML(
-                f'<a href="{bookmark.url}" target="{link_target}" rel="noopener">{bookmark.resolved_title}</a>',
+                f'<a href="{bookmark.url}" target="{link_target}" rel="noopener" class="">{bookmark.resolved_title}</a>',
                 html,
                 count=0
             )
 
-    def assertVisibleTags(self, response, tags: [Tag]):
+    def assertVisibleTags(self, response, tags: List[Tag]):
         self.assertContains(response, 'data-is-tag-item', count=len(tags))
 
         for tag in tags:
             self.assertContains(response, tag.name)
 
-    def assertInvisibleTags(self, response, tags: [Tag]):
+    def assertInvisibleTags(self, response, tags: List[Tag]):
         for tag in tags:
             self.assertNotContains(response, tag.name)
 
+    def assertSelectedTags(self, response, tags: List[Tag]):
+        soup = self.make_soup(response.content.decode())
+        selected_tags = soup.select('p.selected-tags')[0]
+        self.assertIsNotNone(selected_tags)
+
+        tag_list = selected_tags.select('a')
+        self.assertEqual(len(tag_list), len(tags))
+
+        for tag in tags:
+            self.assertTrue(tag.name in selected_tags.text, msg=f'Selected tags do not contain: {tag.name}')
+
     def test_should_list_archived_and_user_owned_bookmarks(self):
         other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
         visible_bookmarks = [
@@ -119,7 +132,7 @@ class BookmarkArchivedViewTestCase(TestCase, BookmarkFactoryMixin):
             self.setup_tag(),
         ]
 
-        self.setup_bookmark(is_archived=True, tags=[visible_tags[0]], title='searchvalue'),
+        self.setup_bookmark(is_archived=True, tags=[visible_tags[0]], title='searchvalue')
         self.setup_bookmark(is_archived=True, tags=[visible_tags[1]], title='searchvalue')
         self.setup_bookmark(is_archived=True, tags=[visible_tags[2]], title='searchvalue')
         self.setup_bookmark(is_archived=True, tags=[invisible_tags[0]])
@@ -131,6 +144,20 @@ class BookmarkArchivedViewTestCase(TestCase, BookmarkFactoryMixin):
         self.assertVisibleTags(response, visible_tags)
         self.assertInvisibleTags(response, invisible_tags)
 
+    def test_should_display_selected_tags_from_query(self):
+        tags = [
+            self.setup_tag(),
+            self.setup_tag(),
+            self.setup_tag(),
+            self.setup_tag(),
+            self.setup_tag(),
+        ]
+        self.setup_bookmark(is_archived=True, tags=tags)
+
+        response = self.client.get(reverse('bookmarks:archived') + f'?q=%23{tags[0].name}+%23{tags[1].name}')
+
+        self.assertSelectedTags(response, [tags[0], tags[1]])
+
     def test_should_open_bookmarks_in_new_page_by_default(self):
         visible_bookmarks = [
             self.setup_bookmark(is_archived=True),

bookmarks/tests/test_bookmark_archived_view_performance.py

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

bookmarks/tests/test_bookmark_edit_view.py

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

bookmarks/tests/test_bookmark_index_view.py

@@ -1,47 +1,61 @@
+from typing import List
+import urllib.parse
+
 from django.contrib.auth.models import User
 from django.test import TestCase
 from django.urls import reverse
 
 from bookmarks.models import Bookmark, Tag, UserProfile
-from bookmarks.tests.helpers import BookmarkFactoryMixin
+from bookmarks.tests.helpers import BookmarkFactoryMixin, HtmlTestMixin
 
 
-class BookmarkIndexViewTestCase(TestCase, BookmarkFactoryMixin):
+class BookmarkIndexViewTestCase(TestCase, BookmarkFactoryMixin, HtmlTestMixin):
 
     def setUp(self) -> None:
         user = self.get_or_create_test_user()
         self.client.force_login(user)
 
-    def assertVisibleBookmarks(self, response, bookmarks: [Bookmark], link_target: str = '_blank'):
+    def assertVisibleBookmarks(self, response, bookmarks: List[Bookmark], link_target: str = '_blank'):
         html = response.content.decode()
         self.assertContains(response, 'data-is-bookmark-item', count=len(bookmarks))
 
         for bookmark in bookmarks:
             self.assertInHTML(
-                f'<a href="{bookmark.url}" target="{link_target}" rel="noopener">{bookmark.resolved_title}</a>',
+                f'<a href="{bookmark.url}" target="{link_target}" rel="noopener" class="">{bookmark.resolved_title}</a>',
                 html
             )
 
-    def assertInvisibleBookmarks(self, response, bookmarks: [Bookmark], link_target: str = '_blank'):
+    def assertInvisibleBookmarks(self, response, bookmarks: List[Bookmark], link_target: str = '_blank'):
         html = response.content.decode()
 
         for bookmark in bookmarks:
             self.assertInHTML(
-                f'<a href="{bookmark.url}" target="{link_target}" rel="noopener">{bookmark.resolved_title}</a>',
+                f'<a href="{bookmark.url}" target="{link_target}" rel="noopener" class="">{bookmark.resolved_title}</a>',
                 html,
                 count=0
             )
 
-    def assertVisibleTags(self, response, tags: [Tag]):
+    def assertVisibleTags(self, response, tags: List[Tag]):
         self.assertContains(response, 'data-is-tag-item', count=len(tags))
 
         for tag in tags:
             self.assertContains(response, tag.name)
 
-    def assertInvisibleTags(self, response, tags: [Tag]):
+    def assertInvisibleTags(self, response, tags: List[Tag]):
         for tag in tags:
             self.assertNotContains(response, tag.name)
 
+    def assertSelectedTags(self, response, tags: List[Tag]):
+        soup = self.make_soup(response.content.decode())
+        selected_tags = soup.select('p.selected-tags')[0]
+        self.assertIsNotNone(selected_tags)
+
+        tag_list = selected_tags.select('a')
+        self.assertEqual(len(tag_list), len(tags))
+
+        for tag in tags:
+            self.assertTrue(tag.name in selected_tags.text, msg=f'Selected tags do not contain: {tag.name}')
+
     def test_should_list_unarchived_and_user_owned_bookmarks(self):
         other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
         visible_bookmarks = [
@@ -119,7 +133,7 @@ class BookmarkIndexViewTestCase(TestCase, BookmarkFactoryMixin):
             self.setup_tag(),
         ]
 
-        self.setup_bookmark(tags=[visible_tags[0]], title='searchvalue'),
+        self.setup_bookmark(tags=[visible_tags[0]], title='searchvalue')
         self.setup_bookmark(tags=[visible_tags[1]], title='searchvalue')
         self.setup_bookmark(tags=[visible_tags[2]], title='searchvalue')
         self.setup_bookmark(tags=[invisible_tags[0]])
@@ -131,6 +145,20 @@ class BookmarkIndexViewTestCase(TestCase, BookmarkFactoryMixin):
         self.assertVisibleTags(response, visible_tags)
         self.assertInvisibleTags(response, invisible_tags)
 
+    def test_should_display_selected_tags_from_query(self):
+        tags = [
+            self.setup_tag(),
+            self.setup_tag(),
+            self.setup_tag(),
+            self.setup_tag(),
+            self.setup_tag(),
+        ]
+        self.setup_bookmark(tags=tags)
+
+        response = self.client.get(reverse('bookmarks:index') + f'?q=%23{tags[0].name}+%23{tags[1].name}')
+
+        self.assertSelectedTags(response, [tags[0], tags[1]])
+
     def test_should_open_bookmarks_in_new_page_by_default(self):
         visible_bookmarks = [
             self.setup_bookmark(),
@@ -157,7 +185,29 @@ class BookmarkIndexViewTestCase(TestCase, BookmarkFactoryMixin):
 
         self.assertVisibleBookmarks(response, visible_bookmarks, '_self')
 
-    def test_should_show_link_for_untagged_bookmarks(self):
-        response = self.client.get(reverse('bookmarks:index'))
+    def test_edit_link_return_url_should_contain_query_params(self):
+        bookmark = self.setup_bookmark(title='foo')
 
-        self.assertContains(response, '<a href="?q=!untagged" class="text-gray text-sm">Show Untagged</a>')
+        # without query params
+        url = reverse('bookmarks:index')
+        response = self.client.get(url)
+        html = response.content.decode()
+        edit_url = reverse('bookmarks:edit', args=[bookmark.id])
+        return_url = urllib.parse.quote_plus(url)
+
+        self.assertInHTML(f'''
+            <a href="{edit_url}?return_url={return_url}"
+               class="btn btn-link btn-sm">Edit</a>        
+        ''', html)
+
+        # with query params
+        url = reverse('bookmarks:index') + '?q=foo&user=user'
+        response = self.client.get(url)
+        html = response.content.decode()
+        edit_url = reverse('bookmarks:edit', args=[bookmark.id])
+        return_url = urllib.parse.quote_plus(url)
+
+        self.assertInHTML(f'''
+            <a href="{edit_url}?return_url={return_url}"
+               class="btn btn-link btn-sm">Edit</a>        
+        ''', html)

bookmarks/tests/test_bookmark_index_view_performance.py

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

bookmarks/tests/test_bookmark_new_view.py

@@ -19,6 +19,8 @@ class BookmarkNewViewTestCase(TestCase, BookmarkFactoryMixin):
             'tag_string': 'tag1 tag2',
             'title': 'test title',
             'description': 'test description',
+            'unread': False,
+            'shared': False,
             'auto_close': '',
         }
         return {**form_data, **overrides}
@@ -35,9 +37,32 @@ class BookmarkNewViewTestCase(TestCase, BookmarkFactoryMixin):
         self.assertEqual(bookmark.url, form_data['url'])
         self.assertEqual(bookmark.title, form_data['title'])
         self.assertEqual(bookmark.description, form_data['description'])
+        self.assertEqual(bookmark.unread, form_data['unread'])
+        self.assertEqual(bookmark.shared, form_data['shared'])
         self.assertEqual(bookmark.tags.count(), 2)
-        self.assertEqual(bookmark.tags.all()[0].name, 'tag1')
-        self.assertEqual(bookmark.tags.all()[1].name, 'tag2')
+        tags = bookmark.tags.order_by('name').all()
+        self.assertEqual(tags[0].name, 'tag1')
+        self.assertEqual(tags[1].name, 'tag2')
+
+    def test_should_create_new_unread_bookmark(self):
+        form_data = self.create_form_data({'unread': True})
+
+        self.client.post(reverse('bookmarks:new'), form_data)
+
+        self.assertEqual(Bookmark.objects.count(), 1)
+
+        bookmark = Bookmark.objects.first()
+        self.assertTrue(bookmark.unread)
+
+    def test_should_create_new_shared_bookmark(self):
+        form_data = self.create_form_data({'shared': True})
+
+        self.client.post(reverse('bookmarks:new'), form_data)
+
+        self.assertEqual(Bookmark.objects.count(), 1)
+
+        bookmark = Bookmark.objects.first()
+        self.assertTrue(bookmark.shared)
 
     def test_should_prefill_url_from_url_parameter(self):
         response = self.client.get(reverse('bookmarks:new') + '?url=http://example.com')
@@ -64,7 +89,7 @@ class BookmarkNewViewTestCase(TestCase, BookmarkFactoryMixin):
         response = self.client.get(reverse('bookmarks:new'))
         html = response.content.decode()
 
-        self.assertInHTML('<input type="hidden" name="auto_close" id="id_auto_close">',html)
+        self.assertInHTML('<input type="hidden" name="auto_close" id="id_auto_close">', html)
 
     def test_should_redirect_to_index_view(self):
         form_data = self.create_form_data()
@@ -86,3 +111,30 @@ class BookmarkNewViewTestCase(TestCase, BookmarkFactoryMixin):
         response = self.client.post(reverse('bookmarks:new'), form_data)
 
         self.assertRedirects(response, reverse('bookmarks:close'))
+
+    def test_should_respect_share_profile_setting(self):
+        self.user.profile.enable_sharing = False
+        self.user.profile.save()
+        response = self.client.get(reverse('bookmarks:new'))
+        html = response.content.decode()
+
+        self.assertInHTML('''
+            <label for="id_shared" class="form-checkbox">
+              <input type="checkbox" name="shared" id="id_shared">
+              <i class="form-icon"></i>
+              <span>Share</span>
+            </label>            
+        ''', html, count=0)
+
+        self.user.profile.enable_sharing = True
+        self.user.profile.save()
+        response = self.client.get(reverse('bookmarks:new'))
+        html = response.content.decode()
+
+        self.assertInHTML('''
+            <label for="id_shared" class="form-checkbox">
+              <input type="checkbox" name="shared" id="id_shared">
+              <i class="form-icon"></i>
+              <span>Share</span>
+            </label>            
+        ''', html, count=1)

bookmarks/tests/test_bookmark_search_tag.py

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

bookmarks/tests/test_bookmark_shared_view.py

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

bookmarks/tests/test_bookmark_shared_view_performance.py

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

bookmarks/tests/test_bookmarks_api.py

@@ -35,6 +35,8 @@ class BookmarksApiTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
             expectation['website_title'] = bookmark.website_title
             expectation['website_description'] = bookmark.website_description
             expectation['is_archived'] = bookmark.is_archived
+            expectation['unread'] = bookmark.unread
+            expectation['shared'] = bookmark.shared
             expectation['tag_names'] = tag_names
             expectation['date_added'] = bookmark.date_added.isoformat().replace('+00:00', 'Z')
             expectation['date_modified'] = bookmark.date_modified.isoformat().replace('+00:00', 'Z')
@@ -45,12 +47,92 @@ class BookmarksApiTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
 
         self.assertCountEqual(data_list, expectations)
 
+    def test_list_bookmarks(self):
+        response = self.get(reverse('bookmarks:bookmark-list'), expected_status_code=status.HTTP_200_OK)
+        self.assertBookmarkListEqual(response.data['results'], [self.bookmark1, self.bookmark2, self.bookmark3])
+
+    def test_list_bookmarks_should_filter_by_query(self):
+        response = self.get(reverse('bookmarks:bookmark-list') + '?q=#' + self.tag1.name,
+                            expected_status_code=status.HTTP_200_OK)
+        self.assertBookmarkListEqual(response.data['results'], [self.bookmark1])
+
+    def test_list_archived_bookmarks_does_not_return_unarchived_bookmarks(self):
+        response = self.get(reverse('bookmarks:bookmark-archived'), expected_status_code=status.HTTP_200_OK)
+        self.assertBookmarkListEqual(response.data['results'], [self.archived_bookmark1, self.archived_bookmark2])
+
+    def test_list_archived_bookmarks_should_filter_by_query(self):
+        response = self.get(reverse('bookmarks:bookmark-archived') + '?q=#' + self.tag1.name,
+                            expected_status_code=status.HTTP_200_OK)
+        self.assertBookmarkListEqual(response.data['results'], [self.archived_bookmark1])
+
+    def test_list_shared_bookmarks(self):
+        user1 = self.setup_user(enable_sharing=True)
+        user2 = self.setup_user(enable_sharing=True)
+        user3 = self.setup_user(enable_sharing=True)
+        user4 = self.setup_user(enable_sharing=False)
+        shared_bookmarks = [
+            self.setup_bookmark(shared=True, user=user1),
+            self.setup_bookmark(shared=True, user=user2),
+            self.setup_bookmark(shared=True, user=user3),
+        ]
+        # Unshared bookmarks
+        self.setup_bookmark(shared=False, user=user1)
+        self.setup_bookmark(shared=False, user=user2)
+        self.setup_bookmark(shared=False, user=user3)
+        self.setup_bookmark(shared=True, user=user4)
+
+        response = self.get(reverse('bookmarks:bookmark-shared'), expected_status_code=status.HTTP_200_OK)
+        self.assertBookmarkListEqual(response.data['results'], shared_bookmarks)
+
+    def test_list_shared_bookmarks_should_filter_by_query_and_user(self):
+        # Search by query
+        user1 = self.setup_user(enable_sharing=True)
+        user2 = self.setup_user(enable_sharing=True)
+        user3 = self.setup_user(enable_sharing=True)
+        expected_bookmarks = [
+            self.setup_bookmark(title='searchvalue', shared=True, user=user1),
+            self.setup_bookmark(title='searchvalue', shared=True, user=user2),
+            self.setup_bookmark(title='searchvalue', shared=True, user=user3),
+        ]
+        self.setup_bookmark(shared=True, user=user1),
+        self.setup_bookmark(shared=True, user=user2),
+        self.setup_bookmark(shared=True, user=user3),
+
+        response = self.get(reverse('bookmarks:bookmark-shared') + '?q=searchvalue',
+                            expected_status_code=status.HTTP_200_OK)
+        self.assertBookmarkListEqual(response.data['results'], expected_bookmarks)
+
+        # Search by user
+        user_search_user = self.setup_user(enable_sharing=True)
+        expected_bookmarks = [
+            self.setup_bookmark(shared=True, user=user_search_user),
+            self.setup_bookmark(shared=True, user=user_search_user),
+            self.setup_bookmark(shared=True, user=user_search_user),
+        ]
+        response = self.get(reverse('bookmarks:bookmark-shared') + '?user=' + user_search_user.username,
+                            expected_status_code=status.HTTP_200_OK)
+        self.assertBookmarkListEqual(response.data['results'], expected_bookmarks)
+
+        # Search by query and user
+        combined_search_user = self.setup_user(enable_sharing=True)
+        expected_bookmarks = [
+            self.setup_bookmark(title='searchvalue', shared=True, user=combined_search_user),
+            self.setup_bookmark(title='searchvalue', shared=True, user=combined_search_user),
+            self.setup_bookmark(title='searchvalue', shared=True, user=combined_search_user),
+        ]
+        response = self.get(
+            reverse('bookmarks:bookmark-shared') + '?q=searchvalue&user=' + combined_search_user.username,
+            expected_status_code=status.HTTP_200_OK)
+        self.assertBookmarkListEqual(response.data['results'], expected_bookmarks)
+
     def test_create_bookmark(self):
         data = {
             'url': 'https://example.com/',
             'title': 'Test title',
             'description': 'Test description',
             'is_archived': False,
+            'unread': False,
+            'shared': False,
             'tag_names': ['tag1', 'tag2']
         }
         self.post(reverse('bookmarks:bookmark-list'), data, status.HTTP_201_CREATED)
@@ -59,6 +141,33 @@ class BookmarksApiTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
         self.assertEqual(bookmark.title, data['title'])
         self.assertEqual(bookmark.description, data['description'])
         self.assertFalse(bookmark.is_archived, data['is_archived'])
+        self.assertFalse(bookmark.unread, data['unread'])
+        self.assertFalse(bookmark.shared, data['shared'])
+        self.assertEqual(bookmark.tags.count(), 2)
+        self.assertEqual(bookmark.tags.filter(name=data['tag_names'][0]).count(), 1)
+        self.assertEqual(bookmark.tags.filter(name=data['tag_names'][1]).count(), 1)
+
+    def test_create_bookmark_with_same_url_updates_existing_bookmark(self):
+        original_bookmark = self.setup_bookmark()
+        data = {
+            'url': original_bookmark.url,
+            'title': 'Updated title',
+            'description': 'Updated description',
+            'unread': True,
+            'shared': True,
+            'is_archived': True,
+            'tag_names': ['tag1', 'tag2']
+        }
+        self.post(reverse('bookmarks:bookmark-list'), data, status.HTTP_201_CREATED)
+        bookmark = Bookmark.objects.get(url=data['url'])
+        self.assertEqual(bookmark.id, original_bookmark.id)
+        self.assertEqual(bookmark.url, data['url'])
+        self.assertEqual(bookmark.title, data['title'])
+        self.assertEqual(bookmark.description, data['description'])
+        # 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)
@@ -79,22 +188,6 @@ class BookmarksApiTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
         data = {'url': 'https://example.com/'}
         self.post(reverse('bookmarks:bookmark-list'), data, status.HTTP_201_CREATED)
 
-    def test_list_bookmarks(self):
-        response = self.get(reverse('bookmarks:bookmark-list'), expected_status_code=status.HTTP_200_OK)
-        self.assertBookmarkListEqual(response.data['results'], [self.bookmark1, self.bookmark2, self.bookmark3])
-
-    def test_list_bookmarks_should_filter_by_query(self):
-        response = self.get(reverse('bookmarks:bookmark-list') + '?q=#' + self.tag1.name, expected_status_code=status.HTTP_200_OK)
-        self.assertBookmarkListEqual(response.data['results'], [self.bookmark1])
-
-    def test_list_archived_bookmarks_does_not_return_unarchived_bookmarks(self):
-        response = self.get(reverse('bookmarks:bookmark-archived'), expected_status_code=status.HTTP_200_OK)
-        self.assertBookmarkListEqual(response.data['results'], [self.archived_bookmark1, self.archived_bookmark2])
-
-    def test_list_archived_bookmarks_should_filter_by_query(self):
-        response = self.get(reverse('bookmarks:bookmark-archived') + '?q=#' + self.tag1.name, expected_status_code=status.HTTP_200_OK)
-        self.assertBookmarkListEqual(response.data['results'], [self.archived_bookmark1])
-
     def test_create_archived_bookmark(self):
         data = {
             'url': 'https://example.com/',
@@ -113,12 +206,36 @@ class BookmarksApiTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
         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_minimal_payload_does_not_archive(self):
+    def test_create_bookmark_is_not_archived_by_default(self):
         data = {'url': 'https://example.com/'}
         self.post(reverse('bookmarks:bookmark-list'), data, status.HTTP_201_CREATED)
         bookmark = Bookmark.objects.get(url=data['url'])
         self.assertFalse(bookmark.is_archived)
 
+    def test_create_unread_bookmark(self):
+        data = {'url': 'https://example.com/', 'unread': True}
+        self.post(reverse('bookmarks:bookmark-list'), data, status.HTTP_201_CREATED)
+        bookmark = Bookmark.objects.get(url=data['url'])
+        self.assertTrue(bookmark.unread)
+
+    def test_create_bookmark_is_not_unread_by_default(self):
+        data = {'url': 'https://example.com/'}
+        self.post(reverse('bookmarks:bookmark-list'), data, status.HTTP_201_CREATED)
+        bookmark = Bookmark.objects.get(url=data['url'])
+        self.assertFalse(bookmark.unread)
+
+    def test_create_shared_bookmark(self):
+        data = {'url': 'https://example.com/', 'shared': True}
+        self.post(reverse('bookmarks:bookmark-list'), data, status.HTTP_201_CREATED)
+        bookmark = Bookmark.objects.get(url=data['url'])
+        self.assertTrue(bookmark.shared)
+
+    def test_create_bookmark_is_not_shared_by_default(self):
+        data = {'url': 'https://example.com/'}
+        self.post(reverse('bookmarks:bookmark-list'), data, status.HTTP_201_CREATED)
+        bookmark = Bookmark.objects.get(url=data['url'])
+        self.assertFalse(bookmark.shared)
+
     def test_get_bookmark(self):
         url = reverse('bookmarks:bookmark-detail', args=[self.bookmark1.id])
         response = self.get(url, expected_status_code=status.HTTP_200_OK)
@@ -146,6 +263,20 @@ class BookmarksApiTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
         self.assertEqual(updated_bookmark.description, '')
         self.assertEqual(updated_bookmark.tag_names, [])
 
+    def test_update_bookmark_unread_flag(self):
+        data = {'url': 'https://example.com/', 'unread': True}
+        url = reverse('bookmarks:bookmark-detail', args=[self.bookmark1.id])
+        self.put(url, data, expected_status_code=status.HTTP_200_OK)
+        updated_bookmark = Bookmark.objects.get(id=self.bookmark1.id)
+        self.assertEqual(updated_bookmark.unread, True)
+
+    def test_update_bookmark_shared_flag(self):
+        data = {'url': 'https://example.com/', 'shared': True}
+        url = reverse('bookmarks:bookmark-detail', args=[self.bookmark1.id])
+        self.put(url, data, expected_status_code=status.HTTP_200_OK)
+        updated_bookmark = Bookmark.objects.get(id=self.bookmark1.id)
+        self.assertEqual(updated_bookmark.shared, True)
+
     def test_patch_bookmark(self):
         data = {'url': 'https://example.com'}
         url = reverse('bookmarks:bookmark-detail', args=[self.bookmark1.id])
@@ -165,6 +296,30 @@ class BookmarksApiTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
         self.bookmark1.refresh_from_db()
         self.assertEqual(self.bookmark1.description, data['description'])
 
+        data = {'unread': True}
+        url = reverse('bookmarks:bookmark-detail', args=[self.bookmark1.id])
+        self.patch(url, data, expected_status_code=status.HTTP_200_OK)
+        self.bookmark1.refresh_from_db()
+        self.assertTrue(self.bookmark1.unread)
+
+        data = {'unread': False}
+        url = reverse('bookmarks:bookmark-detail', args=[self.bookmark1.id])
+        self.patch(url, data, expected_status_code=status.HTTP_200_OK)
+        self.bookmark1.refresh_from_db()
+        self.assertFalse(self.bookmark1.unread)
+
+        data = {'shared': True}
+        url = reverse('bookmarks:bookmark-detail', args=[self.bookmark1.id])
+        self.patch(url, data, expected_status_code=status.HTTP_200_OK)
+        self.bookmark1.refresh_from_db()
+        self.assertTrue(self.bookmark1.shared)
+
+        data = {'shared': False}
+        url = reverse('bookmarks:bookmark-detail', args=[self.bookmark1.id])
+        self.patch(url, data, expected_status_code=status.HTTP_200_OK)
+        self.bookmark1.refresh_from_db()
+        self.assertFalse(self.bookmark1.shared)
+
         data = {'tag_names': ['updated-tag-1', 'updated-tag-2']}
         url = reverse('bookmarks:bookmark-detail', args=[self.bookmark1.id])
         self.patch(url, data, expected_status_code=status.HTTP_200_OK)
@@ -201,6 +356,7 @@ class BookmarksApiTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
     def test_can_only_access_own_bookmarks(self):
         other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
         inaccessible_bookmark = self.setup_bookmark(user=other_user)
+        inaccessible_shared_bookmark = self.setup_bookmark(user=other_user, shared=True)
         self.setup_bookmark(user=other_user, is_archived=True)
 
         url = reverse('bookmarks:bookmark-list')
@@ -214,14 +370,29 @@ class BookmarksApiTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
         url = reverse('bookmarks:bookmark-detail', args=[inaccessible_bookmark.id])
         self.get(url, expected_status_code=status.HTTP_404_NOT_FOUND)
 
+        url = reverse('bookmarks:bookmark-detail', args=[inaccessible_shared_bookmark.id])
+        self.get(url, expected_status_code=status.HTTP_404_NOT_FOUND)
+
         url = reverse('bookmarks:bookmark-detail', args=[inaccessible_bookmark.id])
         self.put(url, {url: 'https://example.com/'}, expected_status_code=status.HTTP_404_NOT_FOUND)
 
+        url = reverse('bookmarks:bookmark-detail', args=[inaccessible_shared_bookmark.id])
+        self.put(url, {url: 'https://example.com/'}, expected_status_code=status.HTTP_404_NOT_FOUND)
+
         url = reverse('bookmarks:bookmark-detail', args=[inaccessible_bookmark.id])
         self.delete(url, expected_status_code=status.HTTP_404_NOT_FOUND)
 
+        url = reverse('bookmarks:bookmark-detail', args=[inaccessible_shared_bookmark.id])
+        self.delete(url, expected_status_code=status.HTTP_404_NOT_FOUND)
+
         url = reverse('bookmarks:bookmark-archive', args=[inaccessible_bookmark.id])
         self.post(url, expected_status_code=status.HTTP_404_NOT_FOUND)
 
+        url = reverse('bookmarks:bookmark-archive', args=[inaccessible_shared_bookmark.id])
+        self.post(url, expected_status_code=status.HTTP_404_NOT_FOUND)
+
         url = reverse('bookmarks:bookmark-unarchive', args=[inaccessible_bookmark.id])
         self.post(url, expected_status_code=status.HTTP_404_NOT_FOUND)
+
+        url = reverse('bookmarks:bookmark-unarchive', args=[inaccessible_shared_bookmark.id])
+        self.post(url, expected_status_code=status.HTTP_404_NOT_FOUND)

bookmarks/tests/test_bookmarks_list_tag.py

@@ -2,17 +2,23 @@ from dateutil.relativedelta import relativedelta
 from django.core.paginator import Paginator
 from django.template import Template, RequestContext
 from django.test import TestCase, RequestFactory
+from django.urls import reverse
 from django.utils import timezone, formats
 
-from bookmarks.models import Bookmark, UserProfile
+from bookmarks.models import Bookmark, UserProfile, User
 from bookmarks.tests.helpers import BookmarkFactoryMixin
 
 
 class BookmarkListTagTest(TestCase, BookmarkFactoryMixin):
 
-    def assertBookmarksLink(self, html: str, bookmark: Bookmark, link_target: str = '_blank'):
+    def assertBookmarksLink(self, html: str, bookmark: Bookmark, link_target: str = '_blank', unread: bool = False):
         self.assertInHTML(
-            f'<a href="{bookmark.url}" target="{link_target}" rel="noopener">{bookmark.resolved_title}</a>',
+            f'''
+            <a href="{bookmark.url}" 
+                target="{link_target}" 
+                rel="noopener" 
+                class="{'text-italic' if unread else ''}">{bookmark.resolved_title}</a>
+            ''',
             html
         )
 
@@ -36,9 +42,46 @@ class BookmarkListTagTest(TestCase, BookmarkFactoryMixin):
         <span class="text-gray text-sm">|</span>
         ''', html)
 
-    def render_template(self, bookmarks: [Bookmark], template: Template) -> str:
+    def assertBookmarkActions(self, html: str, bookmark: Bookmark):
+        self.assertBookmarkActionsCount(html, bookmark, count=1)
+
+    def assertNoBookmarkActions(self, html: str, bookmark: Bookmark):
+        self.assertBookmarkActionsCount(html, bookmark, count=0)
+
+    def assertBookmarkActionsCount(self, html: str, bookmark: Bookmark, count=1):
+        # Edit link
+        edit_url = reverse('bookmarks:edit', args=[bookmark.id])
+        self.assertInHTML(f'''
+            <a href="{edit_url}?return_url=/test"
+               class="btn btn-link btn-sm">Edit</a>
+        ''', html, count=count)
+        # Archive link
+        self.assertInHTML(f'''
+            <button type="submit" name="archive" value="{bookmark.id}"
+               class="btn btn-link btn-sm">Archive</button>
+        ''', html, count=count)
+        # Delete link
+        self.assertInHTML(f'''
+            <button type="submit" name="remove" value="{bookmark.id}"
+               class="btn btn-link btn-sm btn-confirmation">Remove</button>
+        ''', html, count=count)
+
+    def assertShareInfo(self, html: str, bookmark: Bookmark):
+        self.assertShareInfoCount(html, bookmark, 1)
+
+    def assertNoShareInfo(self, html: str, bookmark: Bookmark):
+        self.assertShareInfoCount(html, bookmark, 0)
+
+    def assertShareInfoCount(self, html: str, bookmark: Bookmark, count=1):
+        self.assertInHTML(f'''
+            <span class="text-gray text-sm">Shared by 
+                <a class="text-gray" href="?user={bookmark.owner.username}">{bookmark.owner.username}</a>
+            </span>
+        ''', html, count=count)
+
+    def render_template(self, bookmarks: [Bookmark], template: Template, url: str = '/test') -> str:
         rf = RequestFactory()
-        request = rf.get('/test')
+        request = rf.get(url)
         request.user = self.get_or_create_test_user()
         paginator = Paginator(bookmarks, 10)
         page = paginator.page(1)
@@ -46,12 +89,12 @@ class BookmarkListTagTest(TestCase, BookmarkFactoryMixin):
         context = RequestContext(request, {'bookmarks': page, 'return_url': '/test'})
         return template.render(context)
 
-    def render_default_template(self, bookmarks: [Bookmark]) -> str:
+    def render_default_template(self, bookmarks: [Bookmark], url: str = '/test') -> str:
         template = Template(
             '{% load bookmarks %}'
             '{% bookmark_list bookmarks return_url %}'
         )
-        return self.render_template(bookmarks, template)
+        return self.render_template(bookmarks, template, url)
 
     def render_template_with_link_target(self, bookmarks: [Bookmark], link_target: str) -> str:
         template = Template(
@@ -114,6 +157,15 @@ class BookmarkListTagTest(TestCase, BookmarkFactoryMixin):
 
         self.assertBookmarksLink(html, bookmark, link_target='_self')
 
+    def test_bookmark_link_target_should_respect_unread_flag(self):
+        bookmark = self.setup_bookmark()
+        html = self.render_template_with_link_target([bookmark], '_self')
+        self.assertBookmarksLink(html, bookmark, link_target='_self', unread=False)
+
+        bookmark = self.setup_bookmark(unread=True)
+        html = self.render_template_with_link_target([bookmark], '_self')
+        self.assertBookmarksLink(html, bookmark, link_target='_self', unread=True)
+
     def test_web_archive_link_target_should_be_blank_by_default(self):
         bookmark = self.setup_bookmark()
         bookmark.date_added = timezone.now() - relativedelta(days=8)
@@ -133,3 +185,29 @@ class BookmarkListTagTest(TestCase, BookmarkFactoryMixin):
         html = self.render_template_with_link_target([bookmark], '_self')
 
         self.assertWebArchiveLink(html, '1 week ago', bookmark.web_archive_snapshot_url, link_target='_self')
+
+    def test_show_bookmark_actions_for_owned_bookmarks(self):
+        bookmark = self.setup_bookmark()
+        html = self.render_default_template([bookmark])
+
+        self.assertBookmarkActions(html, bookmark)
+        self.assertNoShareInfo(html, bookmark)
+
+    def test_show_share_info_for_non_owned_bookmarks(self):
+        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
+        bookmark = self.setup_bookmark(user=other_user)
+        html = self.render_default_template([bookmark])
+
+        self.assertNoBookmarkActions(html, bookmark)
+        self.assertShareInfo(html, bookmark)
+
+    def test_share_info_user_link_keeps_query_params(self):
+        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
+        bookmark = self.setup_bookmark(user=other_user)
+        html = self.render_default_template([bookmark], url='/test?q=foo')
+
+        self.assertInHTML(f'''
+            <span class="text-gray text-sm">Shared by 
+                <a class="text-gray" href="?q=foo&user={bookmark.owner.username}">{bookmark.owner.username}</a>
+            </span>
+        ''', html)

bookmarks/tests/test_bookmarks_service.py

@@ -7,6 +7,7 @@ from django.utils import timezone
 from bookmarks.models import Bookmark, Tag
 from bookmarks.services.bookmarks import create_bookmark, update_bookmark, archive_bookmark, archive_bookmarks, \
     unarchive_bookmark, unarchive_bookmarks, delete_bookmarks, tag_bookmarks, untag_bookmarks
+from bookmarks.services import website_loader
 from bookmarks.tests.helpers import BookmarkFactoryMixin
 from bookmarks.services import tasks
 
@@ -18,6 +19,25 @@ class BookmarkServiceTestCase(TestCase, BookmarkFactoryMixin):
     def setUp(self) -> None:
         self.get_or_create_test_user()
 
+    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',
+                                 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.unread, bookmark_data.unread)
+        self.assertEqual(updated_bookmark.shared, bookmark_data.shared)
+        # Saving a duplicate bookmark should not modify archive flag - right?
+        self.assertFalse(updated_bookmark.is_archived)
+
     def test_create_should_create_web_archive_snapshot(self):
         with patch.object(tasks, 'create_web_archive_snapshot') as mock_create_web_archive_snapshot:
             bookmark_data = Bookmark(url='https://example.com')
@@ -41,6 +61,22 @@ class BookmarkServiceTestCase(TestCase, BookmarkFactoryMixin):
 
             mock_create_web_archive_snapshot.assert_not_called()
 
+    def test_update_should_update_website_metadata_if_url_did_change(self):
+        with patch.object(website_loader, 'load_website_metadata') as mock_load_website_metadata:
+            bookmark = self.setup_bookmark()
+            bookmark.url = 'https://example.com/updated'
+            update_bookmark(bookmark, 'tag1,tag2', self.user)
+
+            mock_load_website_metadata.assert_called_once()
+
+    def test_update_should_not_update_website_metadata_if_url_did_not_change(self):
+        with patch.object(website_loader, 'load_website_metadata') as mock_load_website_metadata:
+            bookmark = self.setup_bookmark()
+            bookmark.title = 'updated title'
+            update_bookmark(bookmark, 'tag1,tag2', self.user)
+
+            mock_load_website_metadata.assert_not_called()
+
     def test_archive_bookmark(self):
         bookmark = Bookmark(
             url='https://example.com',

bookmarks/tests/test_context_path.py

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

bookmarks/tests/test_feeds.py

@@ -0,0 +1,191 @@
+import datetime
+import email
+import urllib.parse
+
+from django.test import TestCase
+from django.urls import reverse
+
+from bookmarks.tests.helpers import BookmarkFactoryMixin
+from bookmarks.models import FeedToken, User
+
+
+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 test_all_returns_404_for_unknown_feed_token(self):
+        response = self.client.get(reverse('bookmarks:feeds.all', args=['foo']))
+
+        self.assertEqual(response.status_code, 404)
+
+    def test_all_metadata(self):
+        feed_url = reverse('bookmarks: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"></atom:link>')
+
+    def test_all_returns_all_unarchived_bookmarks(self):
+        bookmarks = [
+            self.setup_bookmark(),
+            self.setup_bookmark(),
+            self.setup_bookmark(unread=True),
+        ]
+        self.setup_bookmark(is_archived=True)
+        self.setup_bookmark(is_archived=True)
+        self.setup_bookmark(is_archived=True)
+
+        response = self.client.get(reverse('bookmarks:feeds.all', args=[self.token.key]))
+        self.assertEqual(response.status_code, 200)
+
+        self.assertContains(response, '<item>', count=len(bookmarks))
+
+        for bookmark in bookmarks:
+            expected_item = '<item>' \
+                            f'<title>{bookmark.resolved_title}</title>' \
+                            f'<link>{bookmark.url}</link>' \
+                            f'<description>{bookmark.resolved_description}</description>' \
+                            f'<pubDate>{rfc2822_date(bookmark.date_added)}</pubDate>' \
+                            f'<guid>{bookmark.url}</guid>' \
+                            '</item>'
+            self.assertContains(response, expected_item, count=1)
+
+    def test_all_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('bookmarks: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_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('bookmarks: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('bookmarks:feeds.unread', args=['foo']))
+
+        self.assertEqual(response.status_code, 404)
+
+    def test_unread_metadata(self):
+        feed_url = reverse('bookmarks: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"></atom:link>')
+
+    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),
+            self.setup_bookmark(unread=True),
+            self.setup_bookmark(unread=True),
+        ]
+
+        response = self.client.get(reverse('bookmarks:feeds.unread', args=[self.token.key]))
+        self.assertEqual(response.status_code, 200)
+
+        self.assertContains(response, '<item>', count=len(unread_bookmarks))
+
+        for bookmark in unread_bookmarks:
+            expected_item = '<item>' \
+                            f'<title>{bookmark.resolved_title}</title>' \
+                            f'<link>{bookmark.url}</link>' \
+                            f'<description>{bookmark.resolved_description}</description>' \
+                            f'<pubDate>{rfc2822_date(bookmark.date_added)}</pubDate>' \
+                            f'<guid>{bookmark.url}</guid>' \
+                            '</item>'
+            self.assertContains(response, expected_item, count=1)
+
+    def test_unread_with_query(self):
+        tag1 = self.setup_tag()
+        bookmark1 = self.setup_bookmark(unread=True)
+        bookmark2 = self.setup_bookmark(unread=True, tags=[tag1])
+        bookmark3 = self.setup_bookmark(unread=True, tags=[tag1])
+
+        self.setup_bookmark(unread=True)
+        self.setup_bookmark(unread=True)
+        self.setup_bookmark(unread=True)
+
+        feed_url = reverse('bookmarks: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_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('bookmarks:feeds.unread', args=[self.token.key]))
+        self.assertEqual(response.status_code, 200)
+
+        self.assertContains(response, '<item>', count=0)

bookmarks/tests/test_importer.py

@@ -21,6 +21,7 @@ class ImporterTestCase(TestCase, BookmarkFactoryMixin, ImportTestMixin):
             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.unread, html_tag.to_read)
 
             tag_names = parse_tag_string(html_tag.tags)
 
@@ -34,52 +35,16 @@ class ImporterTestCase(TestCase, BookmarkFactoryMixin, ImportTestMixin):
         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='',
+            BookmarkHtmlTag(href='https://example.com/foo', title='Foo title', description='',
                             add_date='2', tags=''),
-            BookmarkHtmlTag(href='https://bar.com', title='Bar title', description='Bar description',
+            BookmarkHtmlTag(href='https://example.com/bar', title='Bar title', description='Bar description',
                             add_date='3', tags='bar-tag, other-tag'),
+            BookmarkHtmlTag(href='https://example.com/baz', title='Baz title', description='Baz description',
+                            add_date='4', 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, 3)
-        self.assertEqual(result.success, 3)
-        self.assertEqual(result.failed, 0)
-
-        # Check bookmarks
-        bookmarks = Bookmark.objects.all()
-        self.assertEqual(len(bookmarks), 3)
-        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', tags='example-tag'),
-            BookmarkHtmlTag(href='https://foo.com', title='Foo title', description='',
-                            add_date='2', tags=''),
-            BookmarkHtmlTag(href='https://bar.com', title='Bar title', description='Bar description',
-                            add_date='3', tags='bar-tag, other-tag'),
-        ]
-        import_html = self.render_html(tags=html_tags)
-        import_netscape_html(import_html, self.get_or_create_test_user())
-
-        # Change data, add some new data
-        html_tags = [
-            BookmarkHtmlTag(href='https://example.com', title='Updated Example title',
-                            description='Updated Example description', add_date='111', tags='updated-example-tag'),
-            BookmarkHtmlTag(href='https://foo.com', title='Updated Foo title', description='Updated Foo description',
-                            add_date='222', tags='new-tag'),
-            BookmarkHtmlTag(href='https://bar.com', title='Updated Bar title', description='Updated Bar description',
-                            add_date='333', tags='updated-bar-tag, updated-other-tag'),
-            BookmarkHtmlTag(href='https://baz.com', add_date='444', 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())
-
         # Check result
         self.assertEqual(result.total, 4)
         self.assertEqual(result.success, 4)
@@ -90,6 +55,48 @@ class ImporterTestCase(TestCase, BookmarkFactoryMixin, ImportTestMixin):
         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', tags='example-tag'),
+            BookmarkHtmlTag(href='https://example.com/foo', title='Foo title', description='',
+                            add_date='2', tags=''),
+            BookmarkHtmlTag(href='https://example.com/bar', title='Bar title', description='Bar description',
+                            add_date='3', tags='bar-tag, other-tag'),
+            BookmarkHtmlTag(href='https://example.com/unread', title='Unread title', description='Unread description',
+                            add_date='3', to_read=True),
+        ]
+        import_html = self.render_html(tags=html_tags)
+        import_netscape_html(import_html, self.get_or_create_test_user())
+
+        # Change data, add some new data
+        html_tags = [
+            BookmarkHtmlTag(href='https://example.com', title='Updated Example title',
+                            description='Updated Example description', add_date='111', tags='updated-example-tag'),
+            BookmarkHtmlTag(href='https://example.com/foo', title='Updated Foo title', description='Updated Foo description',
+                            add_date='222', tags='new-tag'),
+            BookmarkHtmlTag(href='https://example.com/bar', title='Updated Bar title', description='Updated Bar description',
+                            add_date='333', tags='updated-bar-tag, updated-other-tag'),
+            BookmarkHtmlTag(href='https://example.com/unread', title='Unread title', description='Unread description',
+                            add_date='3', to_read=False),
+            BookmarkHtmlTag(href='https://baz.com', add_date='444', 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())
+
+        # Check result
+        self.assertEqual(result.total, 5)
+        self.assertEqual(result.success, 5)
+        self.assertEqual(result.failed, 0)
+
+        # Check bookmarks
+        bookmarks = Bookmark.objects.all()
+        self.assertEqual(len(bookmarks), 5)
+        self.assertBookmarksImported(html_tags)
+
     def test_import_with_some_invalid_bookmarks(self):
         html_tags = [
             BookmarkHtmlTag(href='https://example.com'),
@@ -111,6 +118,19 @@ class ImporterTestCase(TestCase, BookmarkFactoryMixin, ImportTestMixin):
         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'),

bookmarks/tests/test_nav_menu.py

@@ -0,0 +1,30 @@
+from django.test import TestCase
+from django.urls import reverse
+
+from bookmarks.tests.helpers import BookmarkFactoryMixin
+
+
+class NavMenuTestCase(TestCase, BookmarkFactoryMixin):
+
+    def setUp(self) -> None:
+        user = self.get_or_create_test_user()
+        self.client.force_login(user)
+
+    def test_should_respect_share_profile_setting(self):
+        self.user.profile.enable_sharing = False
+        self.user.profile.save()
+        response = self.client.get(reverse('bookmarks:index'))
+        html = response.content.decode()
+
+        self.assertInHTML(f'''
+            <a href="{reverse('bookmarks:shared')}" class="btn btn-link">Shared</a>
+        ''', html, count=0)
+
+        self.user.profile.enable_sharing = True
+        self.user.profile.save()
+        response = self.client.get(reverse('bookmarks:index'))
+        html = response.content.decode()
+
+        self.assertInHTML(f'''
+            <a href="{reverse('bookmarks:shared')}" class="btn btn-link">Shared</a>
+        ''', html, count=2)

bookmarks/tests/test_parser.py

@@ -17,15 +17,18 @@ class ParserTestCase(TestCase, ImportTestMixin):
             self.assertEqual(bookmark.date_added, html_tag.add_date)
             self.assertEqual(bookmark.description, html_tag.description)
             self.assertEqual(bookmark.tag_string, html_tag.tags)
+            self.assertEqual(bookmark.to_read, html_tag.to_read)
 
     def test_parse_bookmarks(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='',
+            BookmarkHtmlTag(href='https://example.com/foo', title='Foo title', description='',
                             add_date='2', tags=''),
-            BookmarkHtmlTag(href='https://bar.com', title='Bar title', description='Bar description',
+            BookmarkHtmlTag(href='https://example.com/bar', title='Bar title', description='Bar description',
                             add_date='3', tags='bar-tag, other-tag'),
+            BookmarkHtmlTag(href='https://example.com/baz', title='Baz title', description='Baz description',
+                            add_date='3', to_read=True),
         ]
         html = self.render_html(html_tags)
         bookmarks = parse(html)

bookmarks/tests/test_queries.py

@@ -343,6 +343,32 @@ class QueriesTestCase(TestCase, BookmarkFactoryMixin):
         query = queries.query_archived_bookmarks(self.user, f'!untagged #{tag.name}')
         self.assertCountEqual(list(query), [])
 
+    def test_query_bookmarks_unread_should_return_unread_bookmarks_only(self):
+        unread_bookmarks = [
+            self.setup_bookmark(unread=True),
+            self.setup_bookmark(unread=True),
+            self.setup_bookmark(unread=True),
+        ]
+        self.setup_bookmark()
+        self.setup_bookmark()
+        self.setup_bookmark()
+
+        query = queries.query_bookmarks(self.user, '!unread')
+        self.assertCountEqual(list(query), unread_bookmarks)
+
+    def test_query_archived_bookmarks_unread_should_return_unread_bookmarks_only(self):
+        unread_bookmarks = [
+            self.setup_bookmark(is_archived=True, unread=True),
+            self.setup_bookmark(is_archived=True, unread=True),
+            self.setup_bookmark(is_archived=True, unread=True),
+        ]
+        self.setup_bookmark(is_archived=True)
+        self.setup_bookmark(is_archived=True)
+        self.setup_bookmark(is_archived=True)
+
+        query = queries.query_archived_bookmarks(self.user, '!unread')
+        self.assertCountEqual(list(query), unread_bookmarks)
+
     def test_query_bookmark_tags_should_return_all_tags_for_empty_query(self):
         self.setup_tag_search_data()
 
@@ -546,3 +572,86 @@ class QueriesTestCase(TestCase, BookmarkFactoryMixin):
 
         query = queries.query_archived_bookmark_tags(self.user, f'!untagged #{tag.name}')
         self.assertCountEqual(list(query), [])
+
+    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.assertQueryResult(query_set, [shared_bookmarks])
+
+        # Should respect search query
+        query_set = queries.query_shared_bookmarks(None, 'test title')
+        self.assertQueryResult(query_set, [[shared_bookmarks[0]]])
+
+        query_set = queries.query_shared_bookmarks(None, '#' + tag.name)
+        self.assertQueryResult(query_set, [[shared_bookmarks[2]]])
+
+    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.assertQueryResult(query_set, [shared_tags])
+
+    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.assertQueryResult(query_set, [users_with_shared_bookmarks])
+
+        # Should respect search query
+        query_set = queries.query_shared_bookmark_users('test title')
+        self.assertQueryResult(query_set, [[users_with_shared_bookmarks[0]]])

bookmarks/tests/test_settings_general_view.py

@@ -34,6 +34,7 @@ class SettingsGeneralViewTestCase(TestCase, BookmarkFactoryMixin):
             'bookmark_date_display': UserProfile.BOOKMARK_DATE_DISPLAY_HIDDEN,
             'bookmark_link_target': UserProfile.BOOKMARK_LINK_TARGET_SELF,
             'web_archive_integration': UserProfile.WEB_ARCHIVE_INTEGRATION_ENABLED,
+            'enable_sharing': True,
         }
         response = self.client.post(reverse('bookmarks:settings.general'), form_data)
 
@@ -44,6 +45,7 @@ class SettingsGeneralViewTestCase(TestCase, BookmarkFactoryMixin):
         self.assertEqual(self.user.profile.bookmark_date_display, form_data['bookmark_date_display'])
         self.assertEqual(self.user.profile.bookmark_link_target, form_data['bookmark_link_target'])
         self.assertEqual(self.user.profile.web_archive_integration, form_data['web_archive_integration'])
+        self.assertEqual(self.user.profile.enable_sharing, form_data['enable_sharing'])
 
     def test_about_shows_version_info(self):
         response = self.client.get(reverse('bookmarks:settings.general'))

bookmarks/tests/test_settings_integrations_view.py

@@ -3,6 +3,7 @@ from django.urls import reverse
 from rest_framework.authtoken.models import Token
 
 from bookmarks.tests.helpers import BookmarkFactoryMixin
+from bookmarks.models import FeedToken
 
 
 class SettingsIntegrationsViewTestCase(TestCase, BookmarkFactoryMixin):
@@ -38,3 +39,28 @@ class SettingsIntegrationsViewTestCase(TestCase, BookmarkFactoryMixin):
         self.client.get(reverse('bookmarks:settings.integrations'))
 
         self.assertEqual(Token.objects.count(), 1)
+
+    def test_should_generate_feed_token_if_not_exists(self):
+        self.assertEqual(FeedToken.objects.count(), 0)
+
+        self.client.get(reverse('bookmarks: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('bookmarks:settings.integrations'))
+
+        self.assertEqual(FeedToken.objects.count(), 1)
+
+    def test_should_display_feed_urls(self):
+        response = self.client.get(reverse('bookmarks:settings.integrations'))
+        html = response.content.decode()
+
+        token = FeedToken.objects.first()
+        self.assertInHTML(f'<a href="http://testserver/feeds/{token.key}/all">All bookmarks</a>', html)
+        self.assertInHTML(f'<a href="http://testserver/feeds/{token.key}/unread">Unread bookmarks</a>', html)

bookmarks/tests/test_tag_cloud_tag.py

@@ -0,0 +1,180 @@
+from typing import List
+
+from django.template import Template, RequestContext
+from django.test import TestCase, RequestFactory
+
+from bookmarks.models import Tag
+from bookmarks.tests.helpers import BookmarkFactoryMixin, HtmlTestMixin
+
+
+class TagCloudTagTest(TestCase, BookmarkFactoryMixin, HtmlTestMixin):
+    def render_template(self, tags: List[Tag], selected_tags: List[Tag] = None, url: str = '/test'):
+        if not selected_tags:
+            selected_tags = []
+
+        rf = RequestFactory()
+        request = rf.get(url)
+        context = RequestContext(request, {
+            'request': request,
+            'tags': tags,
+            'selected_tags': selected_tags,
+        })
+        template_to_render = Template(
+            '{% load bookmarks %}'
+            '{% tag_cloud tags selected_tags %}'
+        )
+        return template_to_render.render(context)
+
+    def assertTagGroups(self, rendered_template: str, groups: List[List[str]]):
+        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))
+
+            for tag_index, tag in enumerate(tags, start=0):
+                link_element = link_elements[tag_index]
+                self.assertEqual(link_element.text.strip(), tag)
+
+    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_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'),
+        ]
+
+        rendered_template = self.render_template(tags)
+
+        self.assertTagGroups(rendered_template, [
+            [
+                'Aardvark',
+                'Alpaca',
+                'Armadillo',
+            ],
+            [
+                'Badger',
+                'Buffalo',
+                'Bumblebee',
+            ],
+            [
+                'Chihuahua',
+                'Cockatoo',
+                'Coyote',
+            ],
+        ])
+
+    def test_no_duplicate_tag_names(self):
+        tags = [
+            self.setup_tag(name='shared', user=self.setup_user()),
+            self.setup_tag(name='shared', user=self.setup_user()),
+            self.setup_tag(name='shared', user=self.setup_user()),
+        ]
+
+        rendered_template = self.render_template(tags)
+
+        self.assertTagGroups(rendered_template, [
+            [
+                'shared',
+            ],
+        ])
+
+    def test_selected_tags(self):
+        tags = [
+            self.setup_tag(name='tag1'),
+            self.setup_tag(name='tag2'),
+        ]
+
+        rendered_template = self.render_template(tags, tags, 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_ignore_casing_when_removing_query_part(self):
+        tags = [
+            self.setup_tag(name='TEST'),
+        ]
+
+        rendered_template = self.render_template(tags, tags, 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()),
+            self.setup_tag(name='shared', user=self.setup_user()),
+            self.setup_tag(name='shared', user=self.setup_user()),
+        ]
+
+        rendered_template = self.render_template(tags, tags, 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_search_terms(self):
+        tag = self.setup_tag(name='tag1')
+
+        rendered_template = self.render_template([tag], [tag], url='/test?q=term1 %23tag1 term2 %21untagged')
+
+        self.assertInHTML('''
+            <a href="?q=term1+term2+%21untagged"
+               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'),
+        ]
+        selected_tags = [
+            tags[0],
+            tags[1],
+        ]
+
+        rendered_template = self.render_template(tags, selected_tags)
+
+        self.assertTagGroups(rendered_template, [
+            ['tag3', 'tag4', 'tag5']
+        ])

bookmarks/tests/test_user_profile_model.py

@@ -10,3 +10,8 @@ class UserProfileTestCase(TestCase):
         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)

bookmarks/tests/test_user_select_tag.py

@@ -0,0 +1,76 @@
+from django.db.models import QuerySet
+from django.template import Template, RequestContext
+from django.test import TestCase, RequestFactory
+
+from bookmarks.models import BookmarkFilters, User
+from bookmarks.tests.helpers import BookmarkFactoryMixin
+
+
+class UserSelectTagTest(TestCase, BookmarkFactoryMixin):
+    def render_template(self, url: str, users: QuerySet[User] = User.objects.all()):
+        rf = RequestFactory()
+        request = rf.get(url)
+        filters = BookmarkFilters(request)
+        context = RequestContext(request, {
+            'request': request,
+            'filters': filters,
+            'users': users,
+        })
+        template_to_render = Template(
+            '{% load bookmarks %}'
+            '{% user_select filters users %}'
+        )
+        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 ''}
+                  data-is-user-option>
+            {user.username}
+          </option>        
+        ''', html)
+
+    def test_empty_option(self):
+        rendered_template = self.render_template('/test')
+
+        self.assertInHTML(f'''
+          <option value="">Everyone</option>        
+        ''', rendered_template)
+
+    def test_render_user_options(self):
+        user1 = User.objects.create_user('user1', 'user1@example.com', 'password123')
+        user2 = User.objects.create_user('user2', 'user2@example.com', 'password123')
+        user3 = User.objects.create_user('user3', 'user3@example.com', 'password123')
+
+        rendered_template = self.render_template('/test', User.objects.all())
+
+        self.assertUserOption(rendered_template, user1)
+        self.assertUserOption(rendered_template, user2)
+        self.assertUserOption(rendered_template, user3)
+
+    def test_preselect_user_option(self):
+        user1 = User.objects.create_user('user1', 'user1@example.com', 'password123')
+        User.objects.create_user('user2', 'user2@example.com', 'password123')
+        User.objects.create_user('user3', 'user3@example.com', 'password123')
+
+        rendered_template = self.render_template('/test?user=user1', User.objects.all())
+
+        self.assertUserOption(rendered_template, user1, True)
+
+    def test_render_hidden_inputs_for_filter_params(self):
+        # Should render hidden inputs if query param exists
+        url = '/test?q=foo&user=john'
+        rendered_template = self.render_template(url)
+
+        self.assertInHTML('''
+            <input type="hidden" name="q" value="foo">
+        ''', rendered_template)
+
+        # Should not render hidden inputs if query param does not exist
+        url = '/test?user=john'
+        rendered_template = self.render_template(url)
+
+        self.assertInHTML('''
+            <input type="hidden" name="q" value="foo">
+        ''', rendered_template, count=0)

bookmarks/urls.py

@@ -4,6 +4,7 @@ from django.views.generic import RedirectView
 
 from bookmarks.api.routes import router
 from bookmarks import views
+from bookmarks.feeds import AllBookmarksFeed, UnreadBookmarksFeed
 
 app_name = 'bookmarks'
 urlpatterns = [
@@ -12,6 +13,7 @@ urlpatterns = [
     # Bookmarks
     path('bookmarks', views.bookmarks.index, name='index'),
     path('bookmarks/archived', views.bookmarks.archived, name='archived'),
+    path('bookmarks/shared', views.bookmarks.shared, name='shared'),
     path('bookmarks/new', views.bookmarks.new, name='new'),
     path('bookmarks/close', views.bookmarks.close, name='close'),
     path('bookmarks/<int:bookmark_id>/edit', views.bookmarks.edit, name='edit'),
@@ -25,5 +27,8 @@ urlpatterns = [
     # Toasts
     path('toasts/acknowledge', views.toasts.acknowledge, name='toasts.acknowledge'),
     # API
-    path('api/', include(router.urls), name='api')
+    path('api/', include(router.urls), name='api'),
+    # Feeds
+    path('feeds/<str:feed_key>/all', AllBookmarksFeed(), name='feeds.all'),
+    path('feeds/<str:feed_key>/unread', UnreadBookmarksFeed(), name='feeds.unread'),
 ]

bookmarks/views/bookmarks.py

@@ -1,13 +1,15 @@
 import urllib.parse
 
 from django.contrib.auth.decorators import login_required
+from django.core.handlers.wsgi import WSGIRequest
 from django.core.paginator import Paginator
+from django.db.models import QuerySet, Q, prefetch_related_objects
 from django.http import HttpResponseRedirect, Http404
 from django.shortcuts import render
 from django.urls import reverse
 
 from bookmarks import queries
-from bookmarks.models import Bookmark, BookmarkForm, build_tag_string
+from bookmarks.models import Bookmark, BookmarkForm, BookmarkFilters, User, Tag, build_tag_string
 from bookmarks.services.bookmarks import create_bookmark, update_bookmark, archive_bookmark, archive_bookmarks, \
     unarchive_bookmark, unarchive_bookmarks, delete_bookmarks, tag_bookmarks, untag_bookmarks
 from bookmarks.utils import get_safe_return_url
@@ -17,30 +19,63 @@ _default_page_size = 30
 
 @login_required
 def index(request):
-    query_string = request.GET.get('q')
-    query_set = queries.query_bookmarks(request.user, query_string)
-    tags = queries.query_bookmark_tags(request.user, query_string)
+    filters = BookmarkFilters(request)
+    query_set = queries.query_bookmarks(request.user, filters.query)
+    tags = queries.query_bookmark_tags(request.user, filters.query)
     base_url = reverse('bookmarks:index')
-    context = get_bookmark_view_context(request, query_set, tags, base_url)
+    context = get_bookmark_view_context(request, filters, query_set, tags, base_url)
     return render(request, 'bookmarks/index.html', context)
 
 
 @login_required
 def archived(request):
-    query_string = request.GET.get('q')
-    query_set = queries.query_archived_bookmarks(request.user, query_string)
-    tags = queries.query_archived_bookmark_tags(request.user, query_string)
+    filters = BookmarkFilters(request)
+    query_set = queries.query_archived_bookmarks(request.user, filters.query)
+    tags = queries.query_archived_bookmark_tags(request.user, filters.query)
     base_url = reverse('bookmarks:archived')
-    context = get_bookmark_view_context(request, query_set, tags, base_url)
+    context = get_bookmark_view_context(request, filters, query_set, tags, base_url)
     return render(request, 'bookmarks/archive.html', context)
 
 
-def get_bookmark_view_context(request, query_set, tags, base_url):
+@login_required
+def shared(request):
+    filters = BookmarkFilters(request)
+    user = User.objects.filter(username=filters.user).first()
+    query_set = queries.query_shared_bookmarks(user, filters.query)
+    tags = queries.query_shared_bookmark_tags(user, filters.query)
+    users = queries.query_shared_bookmark_users(filters.query)
+    base_url = reverse('bookmarks:shared')
+    context = get_bookmark_view_context(request, filters, query_set, tags, base_url)
+    context['users'] = users
+    return render(request, 'bookmarks/shared.html', context)
+
+
+def _get_selected_tags(tags: QuerySet[Tag], query_string: str):
+    parsed_query = queries.parse_query_string(query_string)
+    tag_names = parsed_query['tag_names']
+
+    if len(tag_names) == 0:
+        return []
+
+    condition = Q()
+    for tag_name in parsed_query['tag_names']:
+        condition = condition | Q(name__iexact=tag_name)
+
+    return list(tags.filter(condition))
+
+
+def get_bookmark_view_context(request: WSGIRequest,
+                              filters: BookmarkFilters,
+                              query_set: QuerySet[Bookmark],
+                              tags: QuerySet[Tag],
+                              base_url: str):
     page = request.GET.get('page')
-    query_string = request.GET.get('q')
     paginator = Paginator(query_set, _default_page_size)
     bookmarks = paginator.get_page(page)
-    return_url = generate_return_url(base_url, page, query_string)
+    selected_tags = _get_selected_tags(tags, filters.query)
+    # Prefetch owner relation, this avoids n+1 queries when using the owner in templates
+    prefetch_related_objects(bookmarks.object_list, 'owner')
+    return_url = generate_return_url(base_url, page, filters)
     link_target = request.user.profile.bookmark_link_target
 
     if request.GET.get('tag'):
@@ -51,17 +86,20 @@ def get_bookmark_view_context(request, query_set, tags, base_url):
     return {
         'bookmarks': bookmarks,
         'tags': tags,
-        'query': query_string if query_string else '',
+        'selected_tags': selected_tags,
+        'filters': filters,
         'empty': paginator.count == 0,
         'return_url': return_url,
         'link_target': link_target,
     }
 
 
-def generate_return_url(base_url, page, query_string):
+def generate_return_url(base_url: str, page: int, filters: BookmarkFilters):
     url_query = {}
-    if query_string is not None:
-        url_query['q'] = query_string
+    if filters.query:
+        url_query['q'] = filters.query
+    if filters.user:
+        url_query['user'] = filters.user
     if page is not None:
         url_query['page'] = page
     url_params = urllib.parse.urlencode(url_query)
@@ -162,6 +200,16 @@ def unarchive(request, bookmark_id: int):
     unarchive_bookmark(bookmark)
 
 
+def mark_as_read(request, bookmark_id: int):
+    try:
+        bookmark = Bookmark.objects.get(pk=bookmark_id, owner=request.user)
+    except Bookmark.DoesNotExist:
+        raise Http404('Bookmark does not exist')
+
+    bookmark.unread = False
+    bookmark.save()
+
+
 @login_required
 def action(request):
     # Determine action
@@ -171,6 +219,8 @@ def action(request):
         unarchive(request, request.POST['unarchive'])
     if 'remove' in request.POST:
         remove(request, request.POST['remove'])
+    if 'mark_as_read' in request.POST:
+        mark_as_read(request, request.POST['mark_as_read'])
     if 'bulk_archive' in request.POST:
         bookmark_ids = request.POST.getlist('bookmark_id')
         archive_bookmarks(bookmark_ids, request.user)

bookmarks/views/settings.py

@@ -10,7 +10,7 @@ from django.shortcuts import render
 from django.urls import reverse
 from rest_framework.authtoken.models import Token
 
-from bookmarks.models import UserProfileForm
+from bookmarks.models import UserProfileForm, FeedToken
 from bookmarks.queries import query_bookmarks
 from bookmarks.services import exporter
 from bookmarks.services import importer
@@ -73,11 +73,16 @@ def get_ttl_hash(seconds=3600):
 
 @login_required
 def integrations(request):
-    application_url = request.build_absolute_uri("/bookmarks/new")
+    application_url = request.build_absolute_uri(reverse('bookmarks:new'))
     api_token = Token.objects.get_or_create(user=request.user)[0]
+    feed_token = FeedToken.objects.get_or_create(user=request.user)[0]
+    all_feed_url = request.build_absolute_uri(reverse('bookmarks:feeds.all', args=[feed_token.key]))
+    unread_feed_url = request.build_absolute_uri(reverse('bookmarks:feeds.unread', args=[feed_token.key]))
     return render(request, 'settings/integrations.html', {
         'application_url': application_url,
-        'api_token': api_token.key
+        'api_token': api_token.key,
+        'all_feed_url': all_feed_url,
+        'unread_feed_url': unread_feed_url,
     })
 
 

docs/API.md

@@ -47,6 +47,9 @@ Example response:
       "description": "Example description",
       "website_title": "Website title",
       "website_description": "Website description",
+      "is_archived": false,
+      "unread": false,
+      "shared": false,
       "tag_names": [
         "tag1",
         "tag2"
@@ -94,6 +97,8 @@ Example payload:
   "title": "Example title",
   "description": "Example description",
   "is_archived": false,
+  "unread": false,
+  "shared": false,
   "tag_names": [
     "tag1",
     "tag2"
@@ -107,7 +112,33 @@ Example payload:
 PUT /api/bookmarks/<id>/
 ```
 
-Updates a bookmark. Tags are simply assigned using their names.
+Updates a bookmark.
+This is a full update, which requires at least a URL, and fields that are not specified are cleared or reset to their defaults.
+Tags are simply assigned using their names.
+
+Example payload:
+
+```json
+{
+  "url": "https://example.com",
+  "title": "Example title",
+  "description": "Example description",
+  "tag_names": [
+    "tag1",
+    "tag2"
+  ]
+}
+```
+
+**Patch**
+
+```
+PATCH /api/bookmarks/<id>/
+```
+
+Updates a bookmark partially.
+Allows to modify individual fields of a bookmark.
+Tags are simply assigned using their names.
 
 Example payload:
 

docs/Options.md

@@ -50,4 +50,30 @@ Configures the request timeout in the uwsgi application server. This can be usef
 
 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.
+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 does not automatically create new users, you still need to create users as described in the README, and users need to have the same username as in the auth proxy.
+
+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.

docs/backup.md

@@ -13,7 +13,7 @@ As described in the installation docs, you should mount the `/etc/linkding/data`
 Below, we describe several methods to create a backup of the database:
 
 - Manual backup using the export function from the UI
-- Create a copy of the SQLite databse with the SQLite backup function
+- Create a copy of the SQLite database with the SQLite backup function
 - Create a plain textfile with the contents of the SQLite database with the SQLite dump function
 
 Choose the method that fits you best.

docs/how-to.md

@@ -13,7 +13,7 @@ Chrome on Android does not permit running bookmarklets in the same way you can o
 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: (function() { var bookmarkUrl = window.location; var applicationUrl = 'http://<YOUR_INSTANCE_HERE>/bookmarks/new'; applicationUrl += '?url=' + encodeURIComponent(bookmarkUrl); applicationUrl += '&auto_close'; window.open(applicationUrl);})();
+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.

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "linkding",
-  "version": "1.8.6",
+  "version": "1.11.1",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "linkding",
-      "version": "1.8.6",
+      "version": "1.11.1",
       "license": "ISC",
       "dependencies": {
         "@rollup/plugin-commonjs": "^21.0.2",
@@ -15,7 +15,7 @@
         "rollup-plugin-svelte": "^7.1.0",
         "rollup-plugin-terser": "^7.0.2",
         "spectre.css": "^0.5.8",
-        "svelte": "^3.46.4"
+        "svelte": "^3.49.0"
       }
     },
     "node_modules/@babel/code-frame": {
@@ -41,6 +41,58 @@
         "js-tokens": "^4.0.0"
       }
     },
+    "node_modules/@jridgewell/gen-mapping": {
+      "version": "0.3.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.2.tgz",
+      "integrity": "sha512-mh65xKQAzI6iBcFzwv28KVWSmCkdRBWoOh+bYQGW3+6OZvbbN3TqMGo5hqYxQniRcH9F2VZIoJCm4pa3BPDK/A==",
+      "dependencies": {
+        "@jridgewell/set-array": "^1.0.1",
+        "@jridgewell/sourcemap-codec": "^1.4.10",
+        "@jridgewell/trace-mapping": "^0.3.9"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/resolve-uri": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.0.tgz",
+      "integrity": "sha512-F2msla3tad+Mfht5cJq7LSXcdudKTWCVYUgw6pLFOOHSTtZlj6SWNYAp+AhuqLmWdBO2X5hPrLcu8cVP8fy28w==",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/set-array": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/set-array/-/set-array-1.1.2.tgz",
+      "integrity": "sha512-xnkseuNADM0gt2bs+BvhO0p78Mk762YnZdsuzFV018NoG1Sj1SCQvpSqa7XUaTam5vAGasABV9qXASMKnFMwMw==",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/source-map": {
+      "version": "0.3.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/source-map/-/source-map-0.3.2.tgz",
+      "integrity": "sha512-m7O9o2uR8k2ObDysZYzdfhb08VuEml5oWGiosa1VdaPZ/A6QyPkAJuwN0Q1lhULOf6B7MtQmHENS743hWtCrgw==",
+      "dependencies": {
+        "@jridgewell/gen-mapping": "^0.3.0",
+        "@jridgewell/trace-mapping": "^0.3.9"
+      }
+    },
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.4.14",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.14.tgz",
+      "integrity": "sha512-XPSJHWmi394fuUuzDnGz1wiKqWfo1yXecHQMRf2l6hztTO+nPru658AyDngaBe7isIxEkRsPR3FZh+s7iVa4Uw=="
+    },
+    "node_modules/@jridgewell/trace-mapping": {
+      "version": "0.3.14",
+      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.14.tgz",
+      "integrity": "sha512-bJWEfQ9lPTvm3SneWwRFVLzrh6nhjwqw7TUFFBEMzwvg7t7PCDenf2lDwqo4NQXzdpgBXyFgDWnQA+2vkruksQ==",
+      "dependencies": {
+        "@jridgewell/resolve-uri": "^3.0.3",
+        "@jridgewell/sourcemap-codec": "^1.4.10"
+      }
+    },
     "node_modules/@rollup/plugin-commonjs": {
       "version": "21.0.2",
       "resolved": "https://registry.npmjs.org/@rollup/plugin-commonjs/-/plugin-commonjs-21.0.2.tgz",
@@ -119,6 +171,17 @@
         "@types/node": "*"
       }
     },
+    "node_modules/acorn": {
+      "version": "8.8.0",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.8.0.tgz",
+      "integrity": "sha512-QOxyigPVrpZ2GXT+PFyZTl6TtOFc5egxHIP9IlQ+RbupQuX4RkT/Bee4/kQuC02Xkzg84JcT7oLYtDIQxp+v7w==",
+      "bin": {
+        "acorn": "bin/acorn"
+      },
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
     "node_modules/ansi-styles": {
       "version": "3.2.1",
       "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz",
@@ -145,9 +208,9 @@
       }
     },
     "node_modules/buffer-from": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.1.tgz",
-      "integrity": "sha512-MQcXEUbCKtEo7bhqEs6560Hyd4XaovZlO/k9V3hjVUF/zwW7KBVdSK4gIt/bzwS9MbR5qob+F5jusZsb0YQK2A=="
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz",
+      "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ=="
     },
     "node_modules/builtin-modules": {
       "version": "3.2.0",
@@ -524,23 +587,6 @@
       }
     },
     "node_modules/source-map": {
-      "version": "0.7.3",
-      "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.7.3.tgz",
-      "integrity": "sha512-CkCj6giN3S+n9qrYiBTX5gystlENnRW5jZeNLHpe6aue+SrHcG5VYwujhW9s4dY31mEGsxBDrHR6oI69fTXsaQ==",
-      "engines": {
-        "node": ">= 8"
-      }
-    },
-    "node_modules/source-map-support": {
-      "version": "0.5.19",
-      "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.19.tgz",
-      "integrity": "sha512-Wonm7zOCIJzBGQdB+thsPar0kYuCIzYvxZwlBa87yi/Mdjv7Tip2cyVbLj5o0cFPN4EVkuTwb3GDDyUx2DGnGw==",
-      "dependencies": {
-        "buffer-from": "^1.0.0",
-        "source-map": "^0.6.0"
-      }
-    },
-    "node_modules/source-map-support/node_modules/source-map": {
       "version": "0.6.1",
       "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
       "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
@@ -548,6 +594,15 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/source-map-support": {
+      "version": "0.5.21",
+      "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz",
+      "integrity": "sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==",
+      "dependencies": {
+        "buffer-from": "^1.0.0",
+        "source-map": "^0.6.0"
+      }
+    },
     "node_modules/sourcemap-codec": {
       "version": "1.4.8",
       "resolved": "https://registry.npmjs.org/sourcemap-codec/-/sourcemap-codec-1.4.8.tgz",
@@ -570,21 +625,22 @@
       }
     },
     "node_modules/svelte": {
-      "version": "3.46.4",
-      "resolved": "https://registry.npmjs.org/svelte/-/svelte-3.46.4.tgz",
-      "integrity": "sha512-qKJzw6DpA33CIa+C/rGp4AUdSfii0DOTCzj/2YpSKKayw5WGSS624Et9L1nU1k2OVRS9vaENQXp2CVZNU+xvIg==",
+      "version": "3.49.0",
+      "resolved": "https://registry.npmjs.org/svelte/-/svelte-3.49.0.tgz",
+      "integrity": "sha512-+lmjic1pApJWDfPCpUUTc1m8azDqYCG1JN9YEngrx/hUyIcFJo6VZhj0A1Ai0wqoHcEIuQy+e9tk+4uDgdtsFA==",
       "engines": {
         "node": ">= 8"
       }
     },
     "node_modules/terser": {
-      "version": "5.5.1",
-      "resolved": "https://registry.npmjs.org/terser/-/terser-5.5.1.tgz",
-      "integrity": "sha512-6VGWZNVP2KTUcltUQJ25TtNjx/XgdDsBDKGt8nN0MpydU36LmbPPcMBd2kmtZNNGVVDLg44k7GKeHHj+4zPIBQ==",
+      "version": "5.14.2",
+      "resolved": "https://registry.npmjs.org/terser/-/terser-5.14.2.tgz",
+      "integrity": "sha512-oL0rGeM/WFQCUd0y2QrWxYnq7tfSuKBiqTjRPWrRgB46WD/kiwHwF8T23z78H6Q6kGCuuHcPB+KULHRdxvVGQA==",
       "dependencies": {
+        "@jridgewell/source-map": "^0.3.2",
+        "acorn": "^8.5.0",
         "commander": "^2.20.0",
-        "source-map": "~0.7.2",
-        "source-map-support": "~0.5.19"
+        "source-map-support": "~0.5.20"
       },
       "bin": {
         "terser": "bin/terser"
@@ -623,6 +679,49 @@
         "js-tokens": "^4.0.0"
       }
     },
+    "@jridgewell/gen-mapping": {
+      "version": "0.3.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.2.tgz",
+      "integrity": "sha512-mh65xKQAzI6iBcFzwv28KVWSmCkdRBWoOh+bYQGW3+6OZvbbN3TqMGo5hqYxQniRcH9F2VZIoJCm4pa3BPDK/A==",
+      "requires": {
+        "@jridgewell/set-array": "^1.0.1",
+        "@jridgewell/sourcemap-codec": "^1.4.10",
+        "@jridgewell/trace-mapping": "^0.3.9"
+      }
+    },
+    "@jridgewell/resolve-uri": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.0.tgz",
+      "integrity": "sha512-F2msla3tad+Mfht5cJq7LSXcdudKTWCVYUgw6pLFOOHSTtZlj6SWNYAp+AhuqLmWdBO2X5hPrLcu8cVP8fy28w=="
+    },
+    "@jridgewell/set-array": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/set-array/-/set-array-1.1.2.tgz",
+      "integrity": "sha512-xnkseuNADM0gt2bs+BvhO0p78Mk762YnZdsuzFV018NoG1Sj1SCQvpSqa7XUaTam5vAGasABV9qXASMKnFMwMw=="
+    },
+    "@jridgewell/source-map": {
+      "version": "0.3.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/source-map/-/source-map-0.3.2.tgz",
+      "integrity": "sha512-m7O9o2uR8k2ObDysZYzdfhb08VuEml5oWGiosa1VdaPZ/A6QyPkAJuwN0Q1lhULOf6B7MtQmHENS743hWtCrgw==",
+      "requires": {
+        "@jridgewell/gen-mapping": "^0.3.0",
+        "@jridgewell/trace-mapping": "^0.3.9"
+      }
+    },
+    "@jridgewell/sourcemap-codec": {
+      "version": "1.4.14",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.14.tgz",
+      "integrity": "sha512-XPSJHWmi394fuUuzDnGz1wiKqWfo1yXecHQMRf2l6hztTO+nPru658AyDngaBe7isIxEkRsPR3FZh+s7iVa4Uw=="
+    },
+    "@jridgewell/trace-mapping": {
+      "version": "0.3.14",
+      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.14.tgz",
+      "integrity": "sha512-bJWEfQ9lPTvm3SneWwRFVLzrh6nhjwqw7TUFFBEMzwvg7t7PCDenf2lDwqo4NQXzdpgBXyFgDWnQA+2vkruksQ==",
+      "requires": {
+        "@jridgewell/resolve-uri": "^3.0.3",
+        "@jridgewell/sourcemap-codec": "^1.4.10"
+      }
+    },
     "@rollup/plugin-commonjs": {
       "version": "21.0.2",
       "resolved": "https://registry.npmjs.org/@rollup/plugin-commonjs/-/plugin-commonjs-21.0.2.tgz",
@@ -685,6 +784,11 @@
         "@types/node": "*"
       }
     },
+    "acorn": {
+      "version": "8.8.0",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.8.0.tgz",
+      "integrity": "sha512-QOxyigPVrpZ2GXT+PFyZTl6TtOFc5egxHIP9IlQ+RbupQuX4RkT/Bee4/kQuC02Xkzg84JcT7oLYtDIQxp+v7w=="
+    },
     "ansi-styles": {
       "version": "3.2.1",
       "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz",
@@ -708,9 +812,9 @@
       }
     },
     "buffer-from": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.1.tgz",
-      "integrity": "sha512-MQcXEUbCKtEo7bhqEs6560Hyd4XaovZlO/k9V3hjVUF/zwW7KBVdSK4gIt/bzwS9MbR5qob+F5jusZsb0YQK2A=="
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz",
+      "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ=="
     },
     "builtin-modules": {
       "version": "3.2.0",
@@ -1000,24 +1104,17 @@
       }
     },
     "source-map": {
-      "version": "0.7.3",
-      "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.7.3.tgz",
-      "integrity": "sha512-CkCj6giN3S+n9qrYiBTX5gystlENnRW5jZeNLHpe6aue+SrHcG5VYwujhW9s4dY31mEGsxBDrHR6oI69fTXsaQ=="
+      "version": "0.6.1",
+      "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
+      "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g=="
     },
     "source-map-support": {
-      "version": "0.5.19",
-      "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.19.tgz",
-      "integrity": "sha512-Wonm7zOCIJzBGQdB+thsPar0kYuCIzYvxZwlBa87yi/Mdjv7Tip2cyVbLj5o0cFPN4EVkuTwb3GDDyUx2DGnGw==",
+      "version": "0.5.21",
+      "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz",
+      "integrity": "sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==",
       "requires": {
         "buffer-from": "^1.0.0",
         "source-map": "^0.6.0"
-      },
-      "dependencies": {
-        "source-map": {
-          "version": "0.6.1",
-          "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
-          "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g=="
-        }
       }
     },
     "sourcemap-codec": {
@@ -1039,18 +1136,19 @@
       }
     },
     "svelte": {
-      "version": "3.46.4",
-      "resolved": "https://registry.npmjs.org/svelte/-/svelte-3.46.4.tgz",
-      "integrity": "sha512-qKJzw6DpA33CIa+C/rGp4AUdSfii0DOTCzj/2YpSKKayw5WGSS624Et9L1nU1k2OVRS9vaENQXp2CVZNU+xvIg=="
+      "version": "3.49.0",
+      "resolved": "https://registry.npmjs.org/svelte/-/svelte-3.49.0.tgz",
+      "integrity": "sha512-+lmjic1pApJWDfPCpUUTc1m8azDqYCG1JN9YEngrx/hUyIcFJo6VZhj0A1Ai0wqoHcEIuQy+e9tk+4uDgdtsFA=="
     },
     "terser": {
-      "version": "5.5.1",
-      "resolved": "https://registry.npmjs.org/terser/-/terser-5.5.1.tgz",
-      "integrity": "sha512-6VGWZNVP2KTUcltUQJ25TtNjx/XgdDsBDKGt8nN0MpydU36LmbPPcMBd2kmtZNNGVVDLg44k7GKeHHj+4zPIBQ==",
+      "version": "5.14.2",
+      "resolved": "https://registry.npmjs.org/terser/-/terser-5.14.2.tgz",
+      "integrity": "sha512-oL0rGeM/WFQCUd0y2QrWxYnq7tfSuKBiqTjRPWrRgB46WD/kiwHwF8T23z78H6Q6kGCuuHcPB+KULHRdxvVGQA==",
       "requires": {
+        "@jridgewell/source-map": "^0.3.2",
+        "acorn": "^8.5.0",
         "commander": "^2.20.0",
-        "source-map": "~0.7.2",
-        "source-map-support": "~0.5.19"
+        "source-map-support": "~0.5.20"
       }
     },
     "wrappy": {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "linkding",
-  "version": "1.11.1",
+  "version": "1.14.0",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -25,6 +25,6 @@
     "rollup-plugin-svelte": "^7.1.0",
     "rollup-plugin-terser": "^7.0.2",
     "spectre.css": "^0.5.8",
-    "svelte": "^3.46.4"
+    "svelte": "^3.49.0"
   }
 }

requirements.prod.txt

@@ -3,7 +3,7 @@ beautifulsoup4==4.7.1
 certifi==2019.6.16
 charset-normalizer==2.0.4
 confusable-homoglyphs==3.2.0
-Django==3.2.13
+Django==3.2.15
 django-background-tasks==1.2.5
 django-compat==1.0.15
 django-generate-secret-key==1.0.2

requirements.txt

@@ -4,7 +4,7 @@ certifi==2019.6.16
 charset-normalizer==2.0.4
 confusable-homoglyphs==3.2.0
 coverage==5.5
-Django==3.2.13
+Django==3.2.15
 django-appconf==1.0.4
 django-background-tasks==1.2.5
 django-compat==1.0.15

siteroot/settings/base.py

@@ -107,9 +107,12 @@ AUTH_PASSWORD_VALIDATORS = [
     },
 ]
 
-LOGIN_URL = '/login'
-LOGIN_REDIRECT_URL = '/bookmarks'
-LOGOUT_REDIRECT_URL = '/login'
+# 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/
@@ -127,7 +130,7 @@ USE_TZ = True
 # Static files (CSS, JavaScript, Images)
 # https://docs.djangoproject.com/en/2.2/howto/static-files/
 
-STATIC_URL = '/static/'
+STATIC_URL = '/' + LD_CONTEXT_PATH + 'static/'
 
 # Collect static files in static folder
 STATIC_ROOT = os.path.join(BASE_DIR, 'static')
@@ -179,3 +182,20 @@ MAX_ATTEMPTS = 5
 # specced systems like Raspberries. Should be OK as tasks are not time critical.
 BACKGROUND_TASK_RUN_ASYNC = True
 BACKGROUND_TASK_ASYNC_THREADS = 2
+
+# Enable authentication proxy support if configured
+LD_ENABLE_AUTH_PROXY = os.getenv('LD_ENABLE_AUTH_PROXY', False) in (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

siteroot/settings/dev.py

@@ -44,12 +44,7 @@ LOGGING = {
             'level': 'ERROR',  # Set to DEBUG to log all SQL calls
             'handlers': ['console'],
         },
-        'bookmarks.services.tasks': {  # Log task output
-            'level': 'DEBUG',
-            'handlers': ['console'],
-            'propagate': False,
-        },
-        'bookmarks.services.importer': {  # Log importer debug output
+        'bookmarks': {  # Log importer debug output
             'level': 'DEBUG',
             'handlers': ['console'],
             'propagate': False,

siteroot/urls.py

@@ -13,6 +13,7 @@ Including another URLconf
     1. Import the include() function: from django.urls import include, path
     2. Add a URL to urlpatterns:  path('blog/', include('blog.urls'))
 """
+from django.conf import settings
 from django.contrib.auth import views as auth_views
 from django.urls import path, include
 
@@ -30,6 +31,9 @@ urlpatterns = [
     path('', include('bookmarks.urls')),
 ]
 
+if settings.LD_CONTEXT_PATH:
+    urlpatterns = [path(settings.LD_CONTEXT_PATH, include(urlpatterns))]
+
 if DEBUG:
     import debug_toolbar
 

uwsgi.ini

@@ -12,6 +12,10 @@ uid = www-data
 gid = www-data
 buffer-size = 8192
 
+if-env = LD_CONTEXT_PATH
+static-map = /%(_)static=static
+endif =
+
 if-env = LD_REQUEST_TIMEOUT
 http-timeout = %(_)
 socket-timeout = %(_)

version.txt

@@ -1 +1 @@
-1.11.1
+1.14.0