Bump version

* Fix mobile Safari searchbox style (#62)

* Fix mobile menu not closing on outside click (#62)

.env.sample

@@ -1,3 +1,9 @@
+# Docker container name
 LD_CONTAINER_NAME=linkding
+# Port on the host system that the application should be published on
 LD_HOST_PORT=9090
+# Directory on the host system that should be mounted as data dir into the Docker container
 LD_HOST_DATA_DIR=./data
+
+# Option to disable URL validation for bookmarks completely
+LD_DISABLE_URL_VALIDATION=False

API.md

@@ -49,7 +49,7 @@ Example response:
       "website_description": "Website description",
       "tag_names": [
         "tag1",
-        "tag2"        
+        "tag2"
       ],
       "date_added": "2020-09-26T09:46:23.006313Z",
       "date_modified": "2020-09-26T16:01:14.275335Z"
@@ -59,6 +59,16 @@ Example response:
 }
 ```
 
+**Archived**
+
+```
+GET /api/bookmarks/archived/
+```
+
+List archived bookmarks. 
+
+Parameters and response are the same as for the regular list endpoint.
+
 **Retrieve**
 
 ```

CHANGELOG.md

@@ -1,8 +1,19 @@
 # Changelog
 
+## v1.2.1 (12/01/2021)
+- [**bug**] Bug: Two equal tags with different capitalisation lead to 500 server errors [#65](https://github.com/sissbruecker/linkding/issues/65)
+- [**closed**] Enhancement: category and pagination [#11](https://github.com/sissbruecker/linkding/issues/11)
+
+---
+
+## v1.2.0 (09/01/2021)
+- [**closed**] Add Favicon [#58](https://github.com/sissbruecker/linkding/issues/58)
+- [**closed**] Make tags case-insensitive [#45](https://github.com/sissbruecker/linkding/issues/45)
+
+---
+
 ## v1.1.1 (01/01/2021)
 - [**enhancement**] Add docker-compose support [#54](https://github.com/sissbruecker/linkding/pull/54)
-
 ---
 
 ## v1.1.0 (31/12/2020)

Options.md

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

README.md

@@ -38,7 +38,7 @@ If everything completed successfully the application should now be running and c
 
 If you are using a Linux system you can use the following [shell script](https://github.com/sissbruecker/linkding/blob/master/install-linkding.sh) for an automated setup. The script does basically everything described above, but also handles updating an existing container to a new application version (technically replaces the existing container with a new container built from a newer image, while mounting the same data folder).
 
-The script can be configured using using shell variables - for more details have a look at the script itself.
+The script can be configured using shell variables - for more details have a look at the script itself.
 
 ###  Docker-compose setup
 
@@ -67,6 +67,10 @@ The command will prompt you for a secure password. After the command has complet
 
 If you can not or don't want to use Docker you can install the application manually on your server. To do so you can basically follow the steps from the *Development* section below while cross-referencing the `Dockerfile` and `bootstrap.sh` on how to make the application production-ready.
 
+### Options
+
+Check the [options document](Options.md) on how to configure your linkding installation.
+
 ### Hosting
 
 The application runs in a web-server called [uWSGI](https://uwsgi-docs.readthedocs.io/en/latest/) that is production-ready and that you can expose to the web. If you don't know how to configure your server to expose the application to the web there are several more steps involved. I can not support support the process here, but I can give some pointers on what to search for:
@@ -93,11 +97,7 @@ The application provides a REST API that can be used by 3rd party applications t
 The default timeout for requests is 60 seconds, after which the application server will cancel the request and return the above error.
 Depending on the system that the application runs on, and the number of bookmarks that need to be imported, the import may take longer than the default 60 seconds.
 
-To increase the timeout you can provide a custom timeout to the Docker container using the `LD_REQUEST_TIMEOUT` environment variable:
-
-```
-docker run --name linkding -p 9090:9090 -e LD_REQUEST_TIMEOUT=180 -d sissbruecker/linkding:latest
-```
+To increase the timeout you can configure the [`LD_REQUEST_TIMEOUT` option](Options.md#LD_REQUEST_TIMEOUT).
 
 Note that any proxy servers that you are running in front of linkding may have their own timeout settings, which are not affected by the variable.
 

bookmarks/api/routes.py

@@ -1,4 +1,6 @@
-from rest_framework import viewsets, mixins
+from rest_framework import viewsets, mixins, status
+from rest_framework.decorators import action
+from rest_framework.response import Response
 from rest_framework.routers import DefaultRouter
 
 from bookmarks import queries
@@ -27,6 +29,16 @@ class BookmarkViewSet(viewsets.GenericViewSet,
     def get_serializer_context(self):
         return {'user': self.request.user}
 
+    @action(methods=['get'], detail=False)
+    def archived(self, request):
+        user = request.user
+        query_string = request.GET.get('q')
+        query_set = queries.query_archived_bookmarks(user, query_string)
+        page = self.paginate_queryset(query_set)
+        serializer = self.get_serializer_class()
+        data = serializer(page, many=True).data
+        return self.get_paginated_response(data)
+
 
 class TagViewSet(viewsets.GenericViewSet,
                  mixins.ListModelMixin,

bookmarks/components/SearchAutoComplete.svelte

@@ -8,6 +8,7 @@
     export let placeholder;
     export let value;
     export let tags;
+    export let mode = 'default';
     export let apiClient;
 
     let isFocus = false;
@@ -111,7 +112,9 @@
         let bookmarks = []
 
         if (value && value.length >= 3) {
-            const fetchedBookmarks = await apiClient.getBookmarks(value, {limit: 5, offset: 0})
+            const fetchedBookmarks = mode === 'archive'
+                ? await apiClient.getArchivedBookmarks(value, {limit: 5, offset: 0})
+                : await apiClient.getBookmarks(value, {limit: 5, offset: 0})
             bookmarks = fetchedBookmarks.map(bookmark => {
                 const fullLabel = bookmark.title || bookmark.website_title || bookmark.url
                 const label = clampText(fullLabel, 60)
@@ -189,8 +192,8 @@
 </script>
 
 <div class="form-autocomplete">
-    <div class="form-autocomplete-input" class:is-focused={isFocus}>
-        <input type="search" name="{name}" placeholder="{placeholder}" autocomplete="off" value="{value}"
+    <div class="form-autocomplete-input form-input" class:is-focused={isFocus}>
+        <input type="search" class="form-input" name="{name}" placeholder="{placeholder}" autocomplete="off" value="{value}"
                bind:this={input}
                on:input={handleInput} on:keydown={handleKeyDown} on:focus={handleFocus} on:blur={handleBlur}>
     </div>
@@ -257,6 +260,9 @@
     .form-autocomplete-input {
         padding: 0;
     }
+    .form-autocomplete-input.is-focused {
+        z-index: 2;
+    }
 
     /* TODO: Should be read from theme */
     .menu-item.selected > a {

bookmarks/components/api.js

@@ -11,4 +11,13 @@ export class ApiClient {
             .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}`
+
+        return fetch(url)
+            .then(response => response.json())
+            .then(data => data.results)
+    }
 }

bookmarks/migrations/0005_auto_20210103_1212.py

@@ -0,0 +1,19 @@
+# Generated by Django 2.2.13 on 2021-01-03 12:12
+
+import bookmarks.validators
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('bookmarks', '0004_auto_20200926_1028'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='bookmark',
+            name='url',
+            field=models.CharField(max_length=2048, validators=[bookmarks.validators.BookmarkURLValidator()]),
+        ),
+    ]

bookmarks/migrations/0006_bookmark_is_archived.py

@@ -0,0 +1,18 @@
+# Generated by Django 2.2.13 on 2021-02-14 09:08
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('bookmarks', '0005_auto_20210103_1212'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='bookmark',
+            name='is_archived',
+            field=models.BooleanField(default=False),
+        ),
+    ]

bookmarks/models.py

@@ -5,6 +5,7 @@ from django.contrib.auth import get_user_model
 from django.db import models
 
 from bookmarks.utils import unique
+from bookmarks.validators import BookmarkURLValidator
 
 
 class Tag(models.Model):
@@ -32,12 +33,13 @@ def build_tag_string(tag_names: List[str], delimiter: str = ','):
 
 
 class Bookmark(models.Model):
-    url = models.URLField(max_length=2048)
+    url = models.CharField(max_length=2048, validators=[BookmarkURLValidator()])
     title = models.CharField(max_length=512, blank=True)
     description = models.TextField(blank=True)
     website_title = models.CharField(max_length=512, blank=True, null=True)
     website_description = models.TextField(blank=True, null=True)
     unread = models.BooleanField(default=True)
+    is_archived = models.BooleanField(default=False)
     date_added = models.DateTimeField()
     date_modified = models.DateTimeField()
     date_accessed = models.DateTimeField(blank=True, null=True)
@@ -51,7 +53,12 @@ class Bookmark(models.Model):
 
     @property
     def resolved_title(self):
-        return self.website_title if not self.title else self.title
+        if self.title:
+            return self.title
+        elif self.website_title:
+            return self.website_title
+        else:
+            return self.url
 
     @property
     def resolved_description(self):
@@ -71,7 +78,7 @@ class Bookmark(models.Model):
 
 class BookmarkForm(forms.ModelForm):
     # Use URLField for URL
-    url = forms.URLField()
+    url = forms.CharField(validators=[BookmarkURLValidator()])
     tag_string = forms.CharField(required=False)
     # Do not require title and description in form as we fill these automatically if they are empty
     title = forms.CharField(max_length=512,

bookmarks/queries.py

@@ -1,5 +1,5 @@
 from django.contrib.auth.models import User
-from django.db.models import Q, Count, Aggregate, CharField, Value, BooleanField
+from django.db.models import Q, Count, Aggregate, CharField, Value, BooleanField, QuerySet
 
 from bookmarks.models import Bookmark, Tag
 from bookmarks.utils import unique
@@ -17,7 +17,17 @@ class Concat(Aggregate):
             **extra)
 
 
-def query_bookmarks(user: User, query_string: str):
+def query_bookmarks(user: User, query_string: str) -> QuerySet:
+    return _base_bookmarks_query(user, query_string) \
+        .filter(is_archived=False)
+
+
+def query_archived_bookmarks(user: User, query_string: str) -> QuerySet:
+    return _base_bookmarks_query(user, query_string) \
+        .filter(is_archived=True)
+
+
+def _base_bookmarks_query(user: User, query_string: str) -> QuerySet:
     # Add aggregated tag info to bookmark instances
     query_set = Bookmark.objects \
         .annotate(tag_count=Count('tags'),
@@ -51,7 +61,19 @@ def query_bookmarks(user: User, query_string: str):
     return query_set
 
 
-def query_tags(user: User, query_string: str):
+def query_bookmark_tags(user: User, query_string: str) -> QuerySet:
+    return _base_bookmark_tags_query(user, query_string) \
+        .filter(bookmark__is_archived=False) \
+        .distinct()
+
+
+def query_archived_bookmark_tags(user: User, query_string: str) -> QuerySet:
+    return _base_bookmark_tags_query(user, query_string) \
+        .filter(bookmark__is_archived=True) \
+        .distinct()
+
+
+def _base_bookmark_tags_query(user: User, query_string: str) -> QuerySet:
     query_set = Tag.objects
 
     # Filter for user

bookmarks/services/bookmarks.py

@@ -39,6 +39,20 @@ def update_bookmark(bookmark: Bookmark, tag_string, current_user: User):
     return bookmark
 
 
+def archive_bookmark(bookmark: Bookmark):
+    bookmark.is_archived = True
+    bookmark.date_modified = timezone.now()
+    bookmark.save()
+    return bookmark
+
+
+def unarchive_bookmark(bookmark: Bookmark):
+    bookmark.is_archived = False
+    bookmark.date_modified = timezone.now()
+    bookmark.save()
+    return bookmark
+
+
 def _merge_bookmark_data(from_bookmark: Bookmark, to_bookmark: Bookmark):
     to_bookmark.title = from_bookmark.title
     to_bookmark.description = from_bookmark.description

bookmarks/services/tags.py

@@ -1,3 +1,4 @@
+import logging
 import operator
 from typing import List
 
@@ -7,6 +8,8 @@ from django.utils import timezone
 from bookmarks.models import Tag
 from bookmarks.utils import unique
 
+logger = logging.getLogger(__name__)
+
 
 def get_or_create_tags(tag_names: List[str], user: User):
     tags = [get_or_create_tag(tag_name, user) for tag_name in tag_names]
@@ -21,3 +24,14 @@ def get_or_create_tag(name: str, user: User):
         tag.date_added = timezone.now()
         tag.save()
         return tag
+    except Tag.MultipleObjectsReturned:
+        # Legacy databases might contain duplicate tags with different capitalization
+        first_tag = Tag.objects.filter(name__iexact=name, owner=user).first()
+        message = (
+            "Found multiple tags for the name '{0}' with different capitalization. "
+            "Using the first tag with the name '{1}'. "
+            "Since v.1.2 tags work case-insensitive, which means duplicates of the same name are not allowed anymore. "
+            "To solve this error remove the duplicate tag in admin."
+        ).format(name, first_tag.name)
+        logger.error(message)
+        return first_tag

bookmarks/styles/base.scss

@@ -48,3 +48,8 @@ h2 {
 .container > .columns > .column:not(:first-child) {
   padding-left: 2rem;
 }
+
+// Remove left padding from first pagination link
+.pagination .page-item:first-child a {
+  padding-left: 0;
+}

bookmarks/styles/bookmarks.scss

@@ -1,13 +1,33 @@
-.bookmarks-page {
+.bookmarks-page .search {
+  $searchbox-height: 1.8rem;
 
-  .search input[type=search] {
+  // Regular input
+  input[type='search'] {
     width: 180px;
-    height: 1.8rem;
+    height: $searchbox-height;
+    -webkit-appearance: none;
 
     @media (min-width: $control-width-md) {
       width: 300px;
     }
   }
+
+  // Enhanced auto-complete input
+  // This needs a bit more wrangling to make the CSS component align with the attached button
+  .form-autocomplete {
+    height: $searchbox-height;
+
+    .form-autocomplete-input {
+      height: $searchbox-height;
+      width: 100%;
+
+      input[type='search'] {
+        height: 100%;
+        margin: 0;
+        border: none;
+      }
+    }
+  }
 }
 
 ul.bookmark-list {
@@ -38,6 +58,10 @@ ul.bookmark-list {
   }
 }
 
+.bookmark-pagination {
+  margin-top: 1rem;
+}
+
 .tag-cloud {
 
   a {

bookmarks/styles/shared.scss

@@ -4,7 +4,6 @@ section.content-area {
     border-bottom: solid 1px $border-color;
     display: flex;
     flex-direction: row;
-    align-items: baseline;
     margin-bottom: 16px;
 
     h2 {

bookmarks/templates/bookmarks/archive.html

@@ -0,0 +1,34 @@
+{% 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>Archived bookmarks</h2>
+                <div class="spacer"></div>
+                {% bookmark_search query tags mode='archive' %}
+            </div>
+
+            {% if empty %}
+                {% include 'bookmarks/empty_bookmarks.html' %}
+            {% else %}
+                {% bookmark_list bookmarks return_url %}
+            {% endif %}
+        </section>
+
+        {# Tag list #}
+        <section class="content-area column col-4 hide-md">
+            <div class="content-area-header">
+                <h2>Tags</h2>
+            </div>
+            {% tag_cloud tags %}
+        </section>
+    </div>
+
+    <script src="{% static "bundle.js" %}"></script>
+{% endblock %}

bookmarks/templates/bookmarks/bookmark_list.html

@@ -1,4 +1,5 @@
 {% load shared %}
+{% load pagination %}
 
 <ul class="bookmark-list">
     {% for bookmark in bookmarks %}
@@ -23,6 +24,13 @@
             <div class="actions">
                 <a href="{% url 'bookmarks:edit' bookmark.id %}?return_url={{ return_url }}"
                    class="btn btn-link btn-sm">Edit</a>
+                {% if bookmark.is_archived %}
+                    <a href="{% url 'bookmarks:unarchive' bookmark.id %}?return_url={{ return_url }}"
+                       class="btn btn-link btn-sm">Unarchive</a>
+                {% else %}
+                    <a href="{% url 'bookmarks:archive' bookmark.id %}?return_url={{ return_url }}"
+                       class="btn btn-link btn-sm">Archive</a>
+                {% endif %}
                 <a href="{% url 'bookmarks:remove' bookmark.id %}?return_url={{ return_url }}"
                    class="btn btn-link btn-sm"
                    onclick="return confirm('Do you really want to delete this bookmark?')">Remove</a>
@@ -30,13 +38,7 @@
         </li>
     {% endfor %}
 </ul>
-<div class="pagination">
-    {% if bookmarks.has_next %}
-        <a href="?{% update_query_string page=bookmarks.next_page_number %}"
-           class="btn mr-2">< Older</a>
-    {% endif %}
-    {% if bookmarks.has_previous %}
-        <a href="?{% update_query_string page=bookmarks.previous_page_number %}"
-           class="btn">Newer ></a>
-    {% endif %}
+
+<div class="bookmark-pagination">
+    {% pagination bookmarks %}
 </div>

bookmarks/templates/bookmarks/bookmarklet.html

@@ -1,24 +0,0 @@
-{% extends "bookmarks/layout.html" %}
-
-{% block content %}
-    <div class="columns">
-        <section class="content-area column col-12">
-            <div class="content-area-header">
-                <h2>Bookmarklet</h2>
-            </div>
-            <p>The bookmarklet is a quick way to add new bookmarks without opening the linkding application
-                first. Here's how it works:</p>
-            <ul>
-                <li>Drag the bookmarklet below into your browsers bookmark bar / toolbar</li>
-                <li>Open the website that you want to bookmark</li>
-                <li>Click the bookmarklet in your browsers toolbar</li>
-                <li>linkding opens in a new window  or tab and allows you to add a bookmark for the site</li>
-                <li>After saving the bookmark the linkding window closes and you are back on your website</li>
-            </ul>
-            <p>Drag the following bookmarklet to your browsers toolbar:</p>
-            <a href="javascript: {% include 'bookmarks/bookmarklet.js' %}"
-               class="btn btn-primary">📎 Add bookmark</a>
-        </section>
-    </div>
-{% endblock %}
-

bookmarks/templates/bookmarks/empty_bookmarks.html

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

bookmarks/templates/bookmarks/index.html

@@ -11,17 +11,7 @@
             <div class="content-area-header">
                 <h2>Bookmarks</h2>
                 <div class="spacer"></div>
-                <div class="search">
-                    <form action="{% url 'bookmarks:index' %}" method="get">
-                        <div class="input-group">
-                            <span id="search-input-wrap">
-                                <input type="search" name="q" placeholder="Search for words or #tags"
-                                       value="{{ query }}">
-                            </span>
-                            <input type="submit" value="Search" class="btn input-group-btn">
-                        </div>
-                    </form>
-                </div>
+                {% bookmark_search query tags %}
             </div>
 
             {% if empty %}
@@ -40,24 +30,5 @@
         </section>
     </div>
 
-    {# Replace search input with auto-complete component #}
     <script src="{% static "bundle.js" %}"></script>
-    <script type="application/javascript">
-        const currentTagsString = '{{ tags_string }}';
-        const currentTags = currentTagsString.split(' ');
-        const apiClient = new linkding.ApiClient('{% url 'bookmarks:api-root' %}')
-        const wrapper = document.getElementById('search-input-wrap')
-        const newWrapper = document.createElement('div')
-        new linkding.SearchAutoComplete({
-            target: newWrapper,
-            props: {
-                name: 'q',
-                placeholder: 'Search for words or #tags',
-                value: '{{ query }}',
-                tags: currentTags,
-                apiClient
-            }
-        })
-        wrapper.parentElement.replaceChild(newWrapper, wrapper)
-    </script>
 {% endblock %}

bookmarks/templates/bookmarks/layout.html

@@ -5,7 +5,7 @@
 <html lang="en">
 <head>
     <meta charset="UTF-8">
-    <link rel="icon" href="{% static 'favicon.png' %}" />
+    <link rel="icon" href="{% static 'favicon.png' %}"/>
     <meta name="viewport" content="width=device-width, initial-scale=1.0, minimal-ui">
     <meta name="description" content="Self-hosted bookmark service">
     <meta name="robots" content="index,follow">
@@ -23,39 +23,10 @@
             <h1>linkding</h1>
         </a>
     </section>
-    {# Only nav items menu when logged in #}
+    {# Only show nav items menu when logged in #}
     {% if request.user.is_authenticated %}
         <section class="navbar-section">
-            {# 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:bookmarklet' %}" class="btn btn-link">Bookmarklet</a>
-                <a href="{% url 'bookmarks:settings.index' %}" class="btn btn-link">Settings</a>
-                <a href="{% url 'logout' %}" class="btn btn-link">Logout</a>
-            </div>
-            {# Menu drop-down for smaller devices #}
-            <div class="show-md">
-                <a href="{% url 'bookmarks:new' %}" class="btn btn-primary mr-2">
-                    <i class="icon icon-plus"></i>
-                </a>
-                <div class="dropdown dropdown-right">
-                    <a href="#" class="btn btn-link dropdown-toggle" tabindex="0">
-                        <i class="icon icon-menu icon-2x"></i>
-                    </a>
-                    <!-- menu component -->
-                    <ul class="menu">
-                        <li>
-                            <a href="{% url 'bookmarks:bookmarklet' %}" class="btn btn-link">Bookmarklet</a>
-                        </li>
-                        <li>
-                            <a href="{% url 'bookmarks:settings.index' %}" class="btn btn-link">Settings</a>
-                        </li>
-                        <li>
-                            <a href="{% url 'logout' %}" class="btn btn-link">Logout</a>
-                        </li>
-                    </ul>
-                </div>
-            </div>
+            {% include 'bookmarks/nav_menu.html' %}
         </section>
     {% endif %}
 </header>

bookmarks/templates/bookmarks/nav_menu.html

@@ -0,0 +1,49 @@
+{# Basic menu list #}
+<div class="hide-md">
+    <a href="{% url 'bookmarks:new' %}" class="btn btn-primary mr-2">Add bookmark</a>
+    <a href="{% url 'bookmarks:archived' %}" class="btn btn-link">Archive</a>
+    <a href="{% url 'bookmarks:settings.index' %}" class="btn btn-link">Settings</a>
+    <a href="{% url 'logout' %}" class="btn btn-link">Logout</a>
+</div>
+{# Menu drop-down for smaller devices #}
+<div class="show-md">
+    <a href="{% url 'bookmarks:new' %}" class="btn btn-primary mr-2">
+        <i class="icon icon-plus"></i>
+    </a>
+    <div class="dropdown dropdown-right">
+        <a href="#" id="mobile-nav-menu-trigger" class="btn btn-link dropdown-toggle" tabindex="0">
+            <i class="icon icon-menu icon-2x"></i>
+        </a>
+        <!-- menu component -->
+        <ul class="menu">
+            <li>
+                <a href="{% url 'bookmarks:archived' %}" class="btn btn-link">Archive</a>
+            </li>
+            <li>
+                <a href="{% url 'bookmarks:settings.index' %}" class="btn btn-link">Settings</a>
+            </li>
+            <li>
+                <a href="{% url 'logout' %}" class="btn btn-link">Logout</a>
+            </li>
+        </ul>
+    </div>
+</div>
+<script>
+    // Hide mobile menu on outside click
+    // The Spectre CSS component relies on focus changes to show/hide the dropdown, however mobile browsers like
+    // Safari will not trigger a blur event when clicking on a non-focusable element, so we have to simulate the
+    // behaviour through Javascript
+    const mobileNavMenuTrigger = document.getElementById('mobile-nav-menu-trigger');
+
+    function mobileNavMenuOutsideClickHandler(clickEvent) {
+        if (mobileNavMenuTrigger.parentElement.contains(clickEvent.target)) return
+        mobileNavMenuTrigger.blur();
+    }
+
+    mobileNavMenuTrigger.addEventListener('focus', function () {
+        document.addEventListener('click', mobileNavMenuOutsideClickHandler);
+    })
+    mobileNavMenuTrigger.addEventListener('blur', function () {
+        document.removeEventListener('click', mobileNavMenuOutsideClickHandler);
+    })
+</script>

bookmarks/templates/bookmarks/pagination.html

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

bookmarks/templates/bookmarks/search.html

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

bookmarks/templates/settings/index.html

@@ -51,6 +51,25 @@
             {% endif %}
         </section>
 
+        {# Integrations section #}
+        <section class="content-area">
+            <div class="content-area-header">
+                <a id="bookmarklet"><h2>Bookmarklet</h2></a>
+            </div>
+            <p>The bookmarklet is a quick way to add new bookmarks without opening the linkding application
+                first. Here's how it works:</p>
+            <ul>
+                <li>Drag the bookmarklet below into your browsers bookmark bar / toolbar</li>
+                <li>Open the website that you want to bookmark</li>
+                <li>Click the bookmarklet in your browsers toolbar</li>
+                <li>linkding opens in a new window  or tab and allows you to add a bookmark for the site</li>
+                <li>After saving the bookmark the linkding window closes and you are back on your website</li>
+            </ul>
+            <p>Drag the following bookmarklet to your browsers toolbar:</p>
+            <a href="javascript: {% include 'bookmarks/bookmarklet.js' %}"
+               class="btn btn-primary">📎 Add bookmark</a>
+        </section>
+
         {# API token section #}
         <section class="content-area">
             <div class="content-area-header">

bookmarks/templatetags/bookmarks.py

@@ -61,3 +61,14 @@ def bookmark_list(context, bookmarks: Page, return_url: str):
         'bookmarks': bookmarks,
         'return_url': return_url
     }
+
+
+@register.inclusion_tag('bookmarks/search.html', name='bookmark_search', takes_context=True)
+def bookmark_search(context, query: str, tags: [Tag], mode: str = 'default'):
+    tag_names = [tag.name for tag in tags]
+    tags_string = build_tag_string(tag_names, ' ')
+    return {
+        'query': query,
+        'tags_string': tags_string,
+        'mode': mode,
+    }

bookmarks/templatetags/pagination.py

@@ -0,0 +1,55 @@
+from functools import reduce
+
+from django import template
+from django.core.paginator import Page
+
+NUM_ADJACENT_PAGES = 2
+
+register = template.Library()
+
+
+@register.inclusion_tag('bookmarks/pagination.html', name='pagination', takes_context=True)
+def pagination(context, page: Page):
+    visible_page_numbers = get_visible_page_numbers(page.number, page.paginator.num_pages)
+
+    return {
+        'page': page,
+        'visible_page_numbers': visible_page_numbers
+    }
+
+
+def get_visible_page_numbers(current_page_number: int, num_pages: int) -> [int]:
+    """
+    Generates a list of page indexes that should be rendered
+    The list can contain "holes" which indicate that a range of pages are truncated
+    Holes are indicated with a value of `-1`
+    :param current_page_number:
+    :param num_pages:
+    """
+    visible_pages = set()
+
+    # Add adjacent pages around current page
+    visible_pages |= set(range(
+        max(1, current_page_number - NUM_ADJACENT_PAGES),
+        min(num_pages, current_page_number + NUM_ADJACENT_PAGES) + 1
+    ))
+
+    # Add first page
+    visible_pages.add(1)
+
+    # Add last page
+    visible_pages.add(num_pages)
+
+    # Convert to sorted list
+    visible_pages = list(visible_pages)
+    visible_pages.sort()
+
+    def append_page(result: [int], page_number: int):
+        # Look for holes and insert a -1 as indicator
+        is_hole = len(result) > 0 and result[-1] < page_number - 1
+        if is_hole:
+            result.append(-1)
+        result.append(page_number)
+        return result
+
+    return reduce(append_page, visible_pages, [])

bookmarks/tests/test_bookmark_validation.py

@@ -0,0 +1,90 @@
+import datetime
+
+from django.contrib.auth import get_user_model
+from django.core.exceptions import ValidationError
+from django.test import TestCase, override_settings
+
+from bookmarks.models import BookmarkForm, Bookmark
+
+User = get_user_model()
+
+ENABLED_URL_VALIDATION_TEST_CASES = [
+    ('thisisnotavalidurl', False),
+    ('http://domain', False),
+    ('unknownscheme://domain.com', False),
+    ('http://domain.com', True),
+    ('http://www.domain.com', True),
+    ('https://domain.com', True),
+    ('https://www.domain.com', True),
+]
+
+DISABLED_URL_VALIDATION_TEST_CASES = [
+    ('thisisnotavalidurl', True),
+    ('http://domain', True),
+    ('unknownscheme://domain.com', True),
+    ('http://domain.com', True),
+    ('http://www.domain.com', True),
+    ('https://domain.com', True),
+    ('https://www.domain.com', True),
+]
+
+
+class BookmarkValidationTestCase(TestCase):
+
+    def setUp(self) -> None:
+        self.user = User.objects.create_user('testuser', 'test@example.com', 'password123')
+
+    @override_settings(LD_DISABLE_URL_VALIDATION=False)
+    def test_bookmark_model_should_validate_url_if_not_disabled_in_settings(self):
+        self._run_bookmark_model_url_validity_checks(ENABLED_URL_VALIDATION_TEST_CASES)
+
+    @override_settings(LD_DISABLE_URL_VALIDATION=True)
+    def test_bookmark_model_should_not_validate_url_if_disabled_in_settings(self):
+        self._run_bookmark_model_url_validity_checks(DISABLED_URL_VALIDATION_TEST_CASES)
+
+    def test_bookmark_form_should_validate_required_fields(self):
+        form = BookmarkForm(data={'url': ''})
+
+        self.assertEqual(len(form.errors), 1)
+        self.assertIn('required', str(form.errors))
+
+        form = BookmarkForm(data={'url': None})
+
+        self.assertEqual(len(form.errors), 1)
+        self.assertIn('required', str(form.errors))
+
+    @override_settings(LD_DISABLE_URL_VALIDATION=False)
+    def test_bookmark_form_should_validate_url_if_not_disabled_in_settings(self):
+        self._run_bookmark_form_url_validity_checks(ENABLED_URL_VALIDATION_TEST_CASES)
+
+    @override_settings(LD_DISABLE_URL_VALIDATION=True)
+    def test_bookmark_form_should_not_validate_url_if_disabled_in_settings(self):
+        self._run_bookmark_form_url_validity_checks(DISABLED_URL_VALIDATION_TEST_CASES)
+
+    def _run_bookmark_model_url_validity_checks(self, cases):
+        for case in cases:
+            url, expectation = case
+            bookmark = Bookmark(
+                url=url,
+                date_added=datetime.datetime.now(),
+                date_modified=datetime.datetime.now(),
+                owner=self.user
+            )
+
+            try:
+                bookmark.full_clean()
+                self.assertTrue(expectation, 'Did not expect validation error')
+            except ValidationError as e:
+                self.assertFalse(expectation, 'Expected validation error')
+                self.assertTrue('url' in e.message_dict, 'Expected URL validation to fail')
+
+    def _run_bookmark_form_url_validity_checks(self, cases):
+        for case in cases:
+            url, expectation = case
+            form = BookmarkForm(data={'url': url})
+
+            if expectation:
+                self.assertEqual(len(form.errors), 0)
+            else:
+                self.assertEqual(len(form.errors), 1)
+                self.assertIn('Enter a valid URL', str(form.errors))

bookmarks/tests/test_bookmarks_model.py

@@ -0,0 +1,16 @@
+from django.test import TestCase
+
+from bookmarks.models import Bookmark
+
+
+class BookmarkTestCase(TestCase):
+
+    def test_bookmark_resolved_title(self):
+        bookmark = Bookmark(title='Custom title', website_title='Website title', url='https://example.com')
+        self.assertEqual(bookmark.resolved_title, 'Custom title')
+
+        bookmark = Bookmark(title='', website_title='Website title', url='https://example.com')
+        self.assertEqual(bookmark.resolved_title, 'Website title')
+
+        bookmark = Bookmark(title='', website_title='', url='https://example.com')
+        self.assertEqual(bookmark.resolved_title, 'https://example.com')

bookmarks/tests/test_bookmarks_service.py

@@ -0,0 +1,47 @@
+from django.contrib.auth import get_user_model
+from django.test import TestCase
+from django.utils import timezone
+
+from bookmarks.models import Bookmark
+from bookmarks.services.bookmarks import archive_bookmark, unarchive_bookmark
+
+User = get_user_model()
+
+
+class BookmarkServiceTestCase(TestCase):
+
+    def setUp(self) -> None:
+        self.user = User.objects.create_user('testuser', 'test@example.com', 'password123')
+
+    def test_archive(self):
+        bookmark = Bookmark(
+            url='https://example.com',
+            date_added=timezone.now(),
+            date_modified=timezone.now(),
+            owner=self.user
+        )
+        bookmark.save()
+
+        self.assertFalse(bookmark.is_archived)
+
+        archive_bookmark(bookmark)
+
+        updated_bookmark = Bookmark.objects.get(id=bookmark.id)
+
+        self.assertTrue(updated_bookmark.is_archived)
+
+    def test_unarchive(self):
+        bookmark = Bookmark(
+            url='https://example.com',
+            date_added=timezone.now(),
+            date_modified=timezone.now(),
+            owner=self.user,
+            is_archived=True,
+        )
+        bookmark.save()
+
+        unarchive_bookmark(bookmark)
+
+        updated_bookmark = Bookmark.objects.get(id=bookmark.id)
+
+        self.assertFalse(updated_bookmark.is_archived)

bookmarks/tests/test_pagination_tag.py

@@ -0,0 +1,117 @@
+from django.core.paginator import Paginator
+from django.test import SimpleTestCase, RequestFactory
+from django.template import Template, RequestContext
+
+
+class PaginationTagTest(SimpleTestCase):
+
+    def render_template(self, num_items: int, page_size: int, current_page: int, url: str = '/test') -> str:
+        rf = RequestFactory()
+        request = rf.get(url)
+        paginator = Paginator(range(0, num_items), page_size)
+        page = paginator.page(current_page)
+
+        context = RequestContext(request, {'page': page})
+        template_to_render = Template(
+            '{% load pagination %}'
+            '{% pagination page %}'
+        )
+        return template_to_render.render(context)
+
+    def assertPrevLinkDisabled(self, html: str):
+        self.assertInHTML('''
+            <li class="page-item disabled">
+                <a href="#" tabindex="-1">Previous</a>
+            </li>
+            ''', html)
+
+    def assertPrevLink(self, html: str, page_number: int, href: str = None):
+        href = href if href else '?page={0}'.format(page_number)
+        self.assertInHTML('''
+            <li class="page-item">
+                <a href="{0}" tabindex="-1">Previous</a>
+            </li>
+            '''.format(href), html)
+
+    def assertNextLinkDisabled(self, html: str):
+        self.assertInHTML('''
+            <li class="page-item disabled">
+                <a href="#" tabindex="-1">Next</a>
+            </li>
+            ''', html)
+
+    def assertNextLink(self, html: str, page_number: int, href: str = None):
+        href = href if href else '?page={0}'.format(page_number)
+        self.assertInHTML('''
+            <li class="page-item">
+                <a href="{0}" tabindex="-1">Next</a>
+            </li>
+            '''.format(href), html)
+
+    def assertPageLink(self, html: str, page_number: int, active: bool, count: int = 1, href: str = None):
+        active_class = 'active' if active else ''
+        href = href if href else '?page={0}'.format(page_number)
+        self.assertInHTML('''
+            <li class="page-item {1}">
+                <a href="{2}">{0}</a>
+            </li>
+            '''.format(page_number, active_class, href), html, count=count)
+
+    def assertTruncationIndicators(self, html: str, count: int):
+        self.assertInHTML('''
+            <li class="page-item">
+                <span>...</span>
+            </li>
+            ''', html, count=count)
+
+    def test_previous_disabled_on_page_1(self):
+        rendered_template = self.render_template(100, 10, 1)
+        self.assertPrevLinkDisabled(rendered_template)
+
+    def test_previous_enabled_after_page_1(self):
+        for page_number in range(2, 10):
+            rendered_template = self.render_template(100, 10, page_number)
+            self.assertPrevLink(rendered_template, page_number - 1)
+
+    def test_next_disabled_on_last_page(self):
+        rendered_template = self.render_template(100, 10, 10)
+        self.assertNextLinkDisabled(rendered_template)
+
+    def test_next_enabled_before_last_page(self):
+        for page_number in range(1, 9):
+            rendered_template = self.render_template(100, 10, page_number)
+            self.assertNextLink(rendered_template, page_number + 1)
+
+    def test_truncate_pages_start(self):
+        current_page = 1
+        expected_visible_pages = [1, 2, 3, 10]
+        rendered_template = self.render_template(100, 10, current_page)
+        for page_number in range(1, 10):
+            expected_occurrences = 1 if page_number in expected_visible_pages else 0
+            self.assertPageLink(rendered_template, page_number, page_number == current_page, expected_occurrences)
+        self.assertTruncationIndicators(rendered_template, 1)
+
+    def test_truncate_pages_middle(self):
+        current_page = 5
+        expected_visible_pages = [1, 3, 4, 5, 6, 7, 10]
+        rendered_template = self.render_template(100, 10, current_page)
+        for page_number in range(1, 10):
+            expected_occurrences = 1 if page_number in expected_visible_pages else 0
+            self.assertPageLink(rendered_template, page_number, page_number == current_page, expected_occurrences)
+        self.assertTruncationIndicators(rendered_template, 2)
+
+    def test_truncate_pages_near_end(self):
+        current_page = 9
+        expected_visible_pages = [1, 7, 8, 9, 10]
+        rendered_template = self.render_template(100, 10, current_page)
+        for page_number in range(1, 10):
+            expected_occurrences = 1 if page_number in expected_visible_pages else 0
+            self.assertPageLink(rendered_template, page_number, page_number == current_page, expected_occurrences)
+        self.assertTruncationIndicators(rendered_template, 1)
+
+    def test_extend_existing_query(self):
+        rendered_template = self.render_template(100, 10, 2, url='/test?q=cake')
+        self.assertPrevLink(rendered_template, 1, href='?q=cake&page=1')
+        self.assertPageLink(rendered_template, 1, False, href='?q=cake&page=1')
+        self.assertPageLink(rendered_template, 2, True, href='?q=cake&page=2')
+        self.assertNextLink(rendered_template, 3, href='?q=cake&page=3')

bookmarks/tests/test_queries.py

@@ -0,0 +1,99 @@
+from django.contrib.auth import get_user_model
+from django.test import TestCase
+from django.utils import timezone
+from django.utils.crypto import get_random_string
+from bookmarks.models import Bookmark, Tag
+from bookmarks import queries
+
+User = get_user_model()
+
+
+class QueriesTestCase(TestCase):
+
+    def setUp(self) -> None:
+        self.user = User.objects.create_user('testuser', 'test@example.com', 'password123')
+
+    def setup_bookmark(self, is_archived: bool = False, tags: [Tag] = []):
+        unique_id = get_random_string(length=32)
+        bookmark = Bookmark(
+            url='https://example.com/' + unique_id,
+            date_added=timezone.now(),
+            date_modified=timezone.now(),
+            owner=self.user,
+            is_archived=is_archived
+        )
+        bookmark.save()
+        for tag in tags:
+            bookmark.tags.add(tag)
+        bookmark.save()
+        return bookmark
+
+    def setup_tag(self):
+        name = get_random_string(length=32)
+        tag = Tag(name=name, date_added=timezone.now(), owner=self.user)
+        tag.save()
+        return tag
+
+    def test_query_bookmarks_should_not_return_archived_bookmarks(self):
+        bookmark1 = self.setup_bookmark()
+        bookmark2 = self.setup_bookmark()
+        self.setup_bookmark(is_archived=True)
+        self.setup_bookmark(is_archived=True)
+        self.setup_bookmark(is_archived=True)
+
+        query = queries.query_bookmarks(self.user, '')
+
+        self.assertCountEqual([bookmark1, bookmark2], list(query))
+
+    def test_query_archived_bookmarks_should_not_return_unarchived_bookmarks(self):
+        bookmark1 = self.setup_bookmark(is_archived=True)
+        bookmark2 = self.setup_bookmark(is_archived=True)
+        self.setup_bookmark()
+        self.setup_bookmark()
+        self.setup_bookmark()
+
+        query = queries.query_archived_bookmarks(self.user, '')
+
+        self.assertCountEqual([bookmark1, bookmark2], list(query))
+
+    def test_query_bookmark_tags_should_return_tags_for_unarchived_bookmarks_only(self):
+        tag1 = self.setup_tag()
+        tag2 = self.setup_tag()
+        self.setup_bookmark(tags=[tag1])
+        self.setup_bookmark()
+        self.setup_bookmark(is_archived=True, tags=[tag2])
+
+        query = queries.query_bookmark_tags(self.user, '')
+
+        self.assertCountEqual([tag1], list(query))
+
+    def test_query_bookmark_tags_should_return_distinct_tags(self):
+        tag = self.setup_tag()
+        self.setup_bookmark(tags=[tag])
+        self.setup_bookmark(tags=[tag])
+        self.setup_bookmark(tags=[tag])
+
+        query = queries.query_bookmark_tags(self.user, '')
+
+        self.assertCountEqual([tag], list(query))
+
+    def test_query_archived_bookmark_tags_should_return_tags_for_archived_bookmarks_only(self):
+        tag1 = self.setup_tag()
+        tag2 = self.setup_tag()
+        self.setup_bookmark(tags=[tag1])
+        self.setup_bookmark()
+        self.setup_bookmark(is_archived=True, tags=[tag2])
+
+        query = queries.query_archived_bookmark_tags(self.user, '')
+
+        self.assertCountEqual([tag2], list(query))
+
+    def test_query_archived_bookmark_tags_should_return_distinct_tags(self):
+        tag = self.setup_tag()
+        self.setup_bookmark(is_archived=True, tags=[tag])
+        self.setup_bookmark(is_archived=True, tags=[tag])
+        self.setup_bookmark(is_archived=True, tags=[tag])
+
+        query = queries.query_archived_bookmark_tags(self.user, '')
+
+        self.assertCountEqual([tag], list(query))

bookmarks/tests/test_tags_service.py

@@ -9,7 +9,7 @@ from bookmarks.services.tags import get_or_create_tag, get_or_create_tags
 User = get_user_model()
 
 
-class TagTestCase(TestCase):
+class TagServiceTestCase(TestCase):
 
     def setUp(self) -> None:
         self.user = User.objects.create_user('testuser', 'test@example.com', 'password123')
@@ -42,6 +42,13 @@ class TagTestCase(TestCase):
         self.assertEqual(len(tags), 1)
         self.assertEqual(first_tag.id, second_tag.id)
 
+    def test_get_or_create_tag_should_handle_legacy_dbs_with_existing_duplicates(self):
+        first_tag = Tag.objects.create(name='book', date_added=timezone.now(), owner=self.user)
+        Tag.objects.create(name='Book', date_added=timezone.now(), owner=self.user)
+        retrieved_tag = get_or_create_tag('Book', self.user)
+
+        self.assertEqual(first_tag.id, retrieved_tag.id)
+
     def test_get_or_create_tags_should_return_tags(self):
         books_tag = get_or_create_tag('Book', self.user)
         movies_tag = get_or_create_tag('Movie', self.user)

bookmarks/urls.py

@@ -11,11 +11,13 @@ urlpatterns = [
     url(r'^$', RedirectView.as_view(pattern_name='bookmarks:index', permanent=False)),
     # Bookmarks
     path('bookmarks', views.bookmarks.index, name='index'),
+    path('bookmarks/archived', views.bookmarks.archived, name='archived'),
     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'),
     path('bookmarks/<int:bookmark_id>/remove', views.bookmarks.remove, name='remove'),
-    path('bookmarklet', views.bookmarks.bookmarklet, name='bookmarklet'),
+    path('bookmarks/<int:bookmark_id>/archive', views.bookmarks.archive, name='archive'),
+    path('bookmarks/<int:bookmark_id>/unarchive', views.bookmarks.unarchive, name='unarchive'),
     # Settings
     path('settings', views.settings.index, name='settings.index'),
     path('settings/import', views.settings.bookmark_import, name='settings.import'),

bookmarks/validators.py

@@ -0,0 +1,14 @@
+from django.conf import settings
+from django.core import validators
+
+
+class BookmarkURLValidator(validators.URLValidator):
+    """
+    Extends default Django URLValidator and cancels validation if it is disabled in settings.
+    This allows to switch URL validation on/off dynamically which helps with testing
+    """
+    def __call__(self, value):
+        if settings.LD_DISABLE_URL_VALIDATION:
+            return
+
+        super().__call__(value)

bookmarks/views/bookmarks.py

@@ -8,47 +8,58 @@ from django.urls import reverse
 
 from bookmarks import queries
 from bookmarks.models import Bookmark, BookmarkForm, build_tag_string
-from bookmarks.services.bookmarks import create_bookmark, update_bookmark
-from bookmarks.queries import get_user_tags
+from bookmarks.services.bookmarks import create_bookmark, update_bookmark, archive_bookmark, unarchive_bookmark
 
 _default_page_size = 30
 
 
 @login_required
 def index(request):
-    page = request.GET.get('page')
     query_string = request.GET.get('q')
     query_set = queries.query_bookmarks(request.user, query_string)
+    tags = queries.query_bookmark_tags(request.user, query_string)
+    base_url = reverse('bookmarks:index')
+    context = get_bookmark_view_context(request, 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)
+    base_url = reverse('bookmarks:archived')
+    context = get_bookmark_view_context(request, query_set, tags, base_url)
+    return render(request, 'bookmarks/archive.html', context)
+
+
+def get_bookmark_view_context(request, query_set, tags, base_url):
+    page = request.GET.get('page')
+    query_string = request.GET.get('q')
     paginator = Paginator(query_set, _default_page_size)
     bookmarks = paginator.get_page(page)
-    tags = queries.query_tags(request.user, query_string)
-    tag_names = [tag.name for tag in tags]
-    tags_string = build_tag_string(tag_names, ' ')
-    return_url = generate_index_return_url(page, query_string)
+    return_url = generate_return_url(base_url, page, query_string)
 
     if request.GET.get('tag'):
         mod = request.GET.copy()
         mod.pop('tag')
         request.GET = mod
 
-    context = {
+    return {
         'bookmarks': bookmarks,
         'tags': tags,
-        'tags_string': tags_string,
         'query': query_string if query_string else '',
         'empty': paginator.count == 0,
         'return_url': return_url
     }
-    return render(request, 'bookmarks/index.html', context)
 
 
-def generate_index_return_url(page, query_string):
+def generate_return_url(base_url, page, query_string):
     url_query = {}
     if query_string is not None:
         url_query['q'] = query_string
     if page is not None:
         url_query['page'] = page
-    base_url = reverse('bookmarks:index')
     url_params = urllib.parse.urlencode(url_query)
     return_url = base_url if url_params == '' else base_url + '?' + url_params
     return urllib.parse.quote_plus(return_url)
@@ -76,7 +87,7 @@ def new(request):
         if initial_auto_close:
             form.initial['auto_close'] = 'true'
 
-    all_tags = get_user_tags(request.user)
+    all_tags = queries.get_user_tags(request.user)
     context = {
         'form': form,
         'auto_close': initial_auto_close,
@@ -105,7 +116,7 @@ def edit(request, bookmark_id: int):
 
     form.initial['tag_string'] = build_tag_string(bookmark.tag_names, ' ')
     form.initial['return_url'] = return_url
-    all_tags = get_user_tags(request.user)
+    all_tags = queries.get_user_tags(request.user)
 
     context = {
         'form': form,
@@ -127,10 +138,21 @@ def remove(request, bookmark_id: int):
 
 
 @login_required
-def bookmarklet(request):
-    return render(request, 'bookmarks/bookmarklet.html', {
-        'application_url': request.build_absolute_uri("/bookmarks/new")
-    })
+def archive(request, bookmark_id: int):
+    bookmark = Bookmark.objects.get(pk=bookmark_id)
+    archive_bookmark(bookmark)
+    return_url = request.GET.get('return_url')
+    return_url = return_url if return_url else reverse('bookmarks:index')
+    return HttpResponseRedirect(return_url)
+
+
+@login_required
+def unarchive(request, bookmark_id: int):
+    bookmark = Bookmark.objects.get(pk=bookmark_id)
+    unarchive_bookmark(bookmark)
+    return_url = request.GET.get('return_url')
+    return_url = return_url if return_url else reverse('bookmarks:archived')
+    return HttpResponseRedirect(return_url)
 
 
 @login_required

bookmarks/views/settings.py

@@ -18,10 +18,12 @@ logger = logging.getLogger(__name__)
 def index(request):
     import_success_message = _find_message_with_tag(messages.get_messages(request), 'bookmark_import_success')
     import_errors_message = _find_message_with_tag(messages.get_messages(request), 'bookmark_import_errors')
+    application_url = request.build_absolute_uri("/bookmarks/new")
     api_token = Token.objects.get_or_create(user=request.user)[0]
     return render(request, 'settings/index.html', {
         'import_success_message': import_success_message,
         'import_errors_message': import_errors_message,
+        'application_url': application_url,
         'api_token': api_token.key
     })
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "linkding",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "",
   "main": "index.js",
   "scripts": {

siteroot/settings/base.py

@@ -151,9 +151,15 @@ REST_FRAMEWORK = {
         'rest_framework.authentication.TokenAuthentication',
         'rest_framework.authentication.SessionAuthentication',
     ],
+    'DEFAULT_PERMISSION_CLASSES': [
+        'rest_framework.permissions.IsAuthenticated'
+    ],
     'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.LimitOffsetPagination',
     'PAGE_SIZE': 100
 }
 
 # Registration switch
 ALLOW_REGISTRATION = False
+
+# URL validation flag
+LD_DISABLE_URL_VALIDATION = os.getenv('LD_DISABLE_URL_VALIDATION', False) in (True, 'True', '1')

siteroot/settings/dev.py

@@ -12,21 +12,25 @@ DEBUG = True
 SASS_PROCESSOR_ENABLED = True
 
 # Enable debug logging
-# Logging with SQL statements
 LOGGING = {
     'version': 1,
-    'filters': {
-        'require_debug_true': {
-            '()': 'django.utils.log.RequireDebugTrue',
-        }
+    'disable_existing_loggers': False,
+    'formatters': {
+        'simple': {
+            'format': '{levelname} {message}',
+            'style': '{',
+        },
     },
     'handlers': {
         'console': {
-            'level': 'DEBUG',
-            'filters': ['require_debug_true'],
             'class': 'logging.StreamHandler',
+            'formatter': 'simple'
         }
     },
+    'root': {
+        'handlers': ['console'],
+        'level': 'WARNING',
+    },
     'loggers': {
         'django.db.backends': {
             'level': 'ERROR',  # Set to DEBUG to log all SQL calls

version.txt

@@ -1 +1 @@
-1.2.0
+1.3.0