Bump version

Add support for micro-, nanosecond timestamps in importer (#151 )
Update CHANGELOG.md
2025-08-15 06:29:21 +02:00 · 2021-08-26 12:40:03 +02:00 · 2021-08-26 12:33:54 +02:00 · 2021-08-25 12:36:38 +02:00 · 2021-08-25 10:25:22 +02:00 · 2021-08-25 10:20:35 +02:00
101 changed files with 3794 additions and 394 deletions
--- a/.coveragerc
+++ b/.coveragerc
@@ -0,0 +1,3 @@
+[run]
+source = bookmarks
+omit = bookmarks/tests/*
--- a/.dockerignore
+++ b/.dockerignore
@@ -5,13 +5,22 @@
 /node_modules
 /tmp
 /docs
+/static
+/build

 /.dockerignore
 /.gitignore
-/build-*.sh
 /Dockerfile
+/docker-compose.yml
+/*.sh
 /*.iml
-/package*.json
+/*.patch
+/*.md
+/*.js
+
+# Whitelist files needed in build or prod image
+!/rollup.config.js
+!/bootstrap.sh

 # Remove development settings
 /siteroot/settings/dev.py
--- a/.github/workflows/main.yaml
+++ b/.github/workflows/main.yaml
@@ -12,7 +12,13 @@ jobs:
        uses: actions/setup-python@v1
        with:
          python-version: 3.7
-      - name: Install dependencies
+      - name: Set up Node
+        uses: actions/setup-node@v2
+        with:
+          node-version: 14
+      - name: Install Python dependencies
        run: pip install -r requirements.txt
+      - name: Install Node dependencies
+        run: npm install
      - name: Run tests
        run: python manage.py test
--- a/.idea/codeStyles/codeStyleConfig.xml
+++ b/.idea/codeStyles/codeStyleConfig.xml
@@ -0,0 +1,5 @@
+<component name="ProjectCodeStyleConfiguration">
+  <state>
+    <option name="USE_PER_PROJECT_SETTINGS" value="true" />
+  </state>
+</component>
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,7 +1,77 @@
 # Changelog

+## v1.7.1 (25/08/2021)
+- [**bug**] umlaut/non-ascii characters broken when using bookmarklet (firefox) [#148](https://github.com/sissbruecker/linkding/issues/148)
+- [**bug**] Bookmark import accepts empty URL values [#124](https://github.com/sissbruecker/linkding/issues/124)
+- [**enhancement**] Show the version in the settings [#104](https://github.com/sissbruecker/linkding/issues/104)
+
+---
+
+## v1.7.0 (17/08/2021)
+- Upgrade to Django 3
+- Bump other dependencies
+
+---
+
+## v1.6.5 (15/08/2021)
+- [**enhancement**] query with multiple hashtags very slow [#112](https://github.com/sissbruecker/linkding/issues/112)
+---
+
+## v1.6.4 (13/05/2021)
+- Update dependencies for security fixes
+
+---
+
+## v1.6.3 (07/04/2021)
+- [**bug**] relative names use the wrong "today" after day change [#107](https://github.com/sissbruecker/linkding/issues/107)
+
+---
+
+## v1.6.2 (04/04/2021)
+- [**enhancement**] Expose `date_added` in UI [#85](https://github.com/sissbruecker/linkding/issues/85)
+- [**closed**] Archived bookmarks - no result when searching for a word which is used only as tag [#83](https://github.com/sissbruecker/linkding/issues/83)
+- [**closed**] Add archive/unarchive button to edit bookmark page [#82](https://github.com/sissbruecker/linkding/issues/82)
+- [**enhancement**] Make scraped title and description editable [#80](https://github.com/sissbruecker/linkding/issues/80)
+
+---
+
+## v1.6.1 (31/03/2021)
+- Expose date_added in UI [#85](https://github.com/sissbruecker/linkding/issues/85)
+
+---
+
+## v1.6.0 (29/03/2021)
+- Bulk edit mode [#101](https://github.com/sissbruecker/linkding/pull/101)
+---
+
+## v1.5.0 (28/03/2021)
+- [**closed**] Add a dark mode [#49](https://github.com/sissbruecker/linkding/issues/49)
+---
+
+## v1.4.1 (20/03/2021)
+- Security patches
+- Documentation improvements
+
+---
+
+## v1.4.0 (24/02/2021)
+- [**enhancement**] Improve admin utilization [#76](https://github.com/sissbruecker/linkding/issues/76)
+
+---
+
+## v1.3.3 (18/02/2021)
+- [**closed**] Missing "description" request body parameter in API causes 500 [#78](https://github.com/sissbruecker/linkding/issues/78)
+
+---
+
+## v1.3.2 (18/02/2021)
+- [**closed**] /archive and /unarchive API routes return 404 [#77](https://github.com/sissbruecker/linkding/issues/77)
+- [**closed**] API - /api/check_url?url= with token authetification [#55](https://github.com/sissbruecker/linkding/issues/55)
+
+---
+
 ## v1.3.1 (15/02/2021)
-*No changelog for this release.*
+[enhancement] Enhance delete links with inline confirmation

 ---

--- a/60
+++ b/60
@@ -1,22 +1,54 @@
-FROM python:3.7-slim-stretch
-
-# Install packages required for uswgi
-RUN apt-get update
-RUN apt-get -y install build-essential
-RUN apt-get -y install mime-support
-
-# Install requirements and uwsgi server for running python web apps
+FROM node:current-alpine AS node-build
 WORKDIR /etc/linkding
-COPY requirements.prod.txt ./requirements.txt
-RUN pip install -U pip
-RUN pip install -Ur requirements.txt
-
-# Copy application
+# install build dependencies
+COPY package.json package-lock.json ./
+RUN npm install -g npm && \
+    npm install
+# compile JS components
 COPY . .
+RUN npm run build

+
+FROM python:3.9-slim AS python-base
+RUN apt-get update && apt-get -y install build-essential
+WORKDIR /etc/linkding
+
+
+FROM python-base AS python-build
+# install build dependencies
+COPY requirements.txt requirements.txt
+RUN pip install -U pip && pip install -Ur requirements.txt
+# run Django part of the build
+COPY --from=node-build /etc/linkding .
+RUN python manage.py compilescss && \
+    python manage.py collectstatic --ignore=*.scss && \
+    python manage.py compilescss --delete-files
+
+
+FROM python-base AS prod-deps
+COPY requirements.prod.txt ./requirements.txt
+RUN mkdir /opt/venv && \
+    python -m venv --upgrade-deps --copies /opt/venv && \
+    /opt/venv/bin/pip install --upgrade pip wheel && \
+    /opt/venv/bin/pip install -Ur requirements.txt
+
+
+FROM python:3.9-slim as final
+RUN apt-get update && apt-get -y install mime-support
+WORKDIR /etc/linkding
+# copy prod dependencies
+COPY --from=prod-deps /opt/venv /opt/venv
+# copy output from build stage
+COPY --from=python-build /etc/linkding/static static/
+# copy application code
+COPY . .
 # Expose uwsgi server at port 9090
 EXPOSE 9090
-
+# Activate virtual env
+ENV VIRTUAL_ENV /opt/venv
+ENV PATH /opt/venv/bin:$PATH
+# Allow running containers as an an arbitrary user in the root group, to support deployment scenarios like OpenShift, Podman
+RUN ["chmod", "g+w", "."]
 # Run bootstrap logic
 RUN ["chmod", "+x", "./bootstrap.sh"]
 CMD ["./bootstrap.sh"]
--- a/README.md
+++ b/README.md
@@ -1,12 +1,31 @@
 #  linkding

-*linkding* is a simple bookmark service that you can host yourself. It supports managing bookmarks, categorizing them with tags and has a search function. It provides a bookmarklet for quickly adding new bookmarks while browsing the web. It also supports import / export of bookmarks in the Netscape HTML format. And that's basically it 🙂.
+*linkding* is a simple bookmark service that you can host yourself.
+It's designed be to be minimal, fast and easy to set up using Docker. 

 The name comes from:
 - *link* which is often used as a synonym for URLs and bookmarks in common language
 - *Ding* which is german for *thing*
 - ...so basically some thing for managing your links

+**Feature Overview:**
+- Tags for organizing bookmarks
+- Search by text or tags
+- Bulk editing
+- Bookmark archive
+- Automatically provides titles and descriptions from linked websites 
+- Import and export bookmarks in Netscape HTML format
+- Extensions for [Firefox](https://addons.mozilla.org/de/firefox/addon/linkding-extension/) and [Chrome](https://chrome.google.com/webstore/detail/linkding-extension/beakmhbijpdhipnjhnclmhgjlddhidpe)
+- Bookmarklet that should work in most browsers
+- Dark mode
+- Easy to set up using Docker
+- Uses SQLite as database
+- Works without Javascript
+- ...but has several UI enhancements when Javascript is enabled
+- REST API for developing 3rd party apps
+- Admin panel for user self-service and raw data access
+
+
 **Demo:** https://demo.linkding.link/ (configured with open registration)

 **Screenshot:**
@@ -15,7 +34,7 @@ The name comes from:

 ## Installation

-The easiest way to run linkding is to use [Docker](https://docs.docker.com/get-started/).  The Docker image should be compatible with ARM platforms, so it can be run on a Raspberry Pi.
+The easiest way to run linkding is to use [Docker](https://docs.docker.com/get-started/).  The Docker image is compatible with ARM platforms, so it can be run on a Raspberry Pi.

 There is also the option to set up the installation manually which I do not support, but can give some pointers on below.

@@ -49,7 +68,7 @@ docker-compose up -d

 ### User setup

-Finally you need to create a user so that you can access the frontend. Replace the credentials in the following command and run it:
+Finally you need to create a user so that you can access the application. Replace the credentials in the following command and run it:

 **Docker**
 ```shell
@@ -67,28 +86,32 @@ 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:
+The application runs in a web-server called [uWSGI](https://uwsgi-docs.readthedocs.io/en/latest/) that is production-ready and that you can expose to the web. If you don't know how to configure your server to expose the application to the web there are several more steps involved. I can not support the process here, but I can give some pointers on what to search for:
 - first get the app running (described in this document)
 - open the port that the application is running on in your servers firewall
 - depending on your network configuration, forward the opened port in your network router, so that the application can be addressed from the internet using your public IP address and the opened port

-### Backups
+## Options

-For backups you have two options: manually or automatic.
+Check the [options document](docs/Options.md) on how to configure your linkding installation.

-For manual backups you can export your bookmarks from the UI and store them on a backup device or online service.
+## Administration

-For automatic backups you want to backup the applications database. As described above, for production setups you should [mount](https://stackoverflow.com/questions/23439126/how-to-mount-a-host-directory-in-a-docker-container) the `/etc/linkding/data` directory from the Docker container to a directory on your host system. You can then use a backup tool of your choice to backup the contents of that directory.
+Check the [administration document](docs/Admin.md) on how to use the admin app that is bundled with linkding.
+
+## Backups
+
+Check the [backups document](docs/backup.md) for options on how to create backups.
+
+## How To
+
+Check the [how-to document](docs/how-to.md) for tips and tricks around using linkding.

 ## API

-The application provides a REST API that can be used by 3rd party applications to manage bookmarks. Check the [API docs](API.md) for further information.
+The application provides a REST API that can be used by 3rd party applications to manage bookmarks. Check the [API docs](docs/API.md) for further information.

 ## Troubleshooting

@@ -103,7 +126,7 @@ Note that any proxy servers that you are running in front of linkding may have t

 ## Development

-The application is open source, so you are free to modify or contribute. The application is built using the Django web framework. You can get started by checking out the excellent Django docs: https://docs.djangoproject.com/en/3.0/. The `bookmarks` folder contains the actual bookmark application, `siteroot` is the Django root application. Other than that the code should be self-explanatory / standard Django stuff 🙂.
+The application is open source, so you are free to modify or contribute. The application is built using the Django web framework. You can get started by checking out the excellent Django docs: https://docs.djangoproject.com/en/3.2/. The `bookmarks` folder contains the actual bookmark application, `siteroot` is the Django root application. Other than that the code should be self-explanatory / standard Django stuff 🙂.

 ### Prerequisites
 - Python 3
@@ -148,4 +171,4 @@ The frontend is now available under http://localhost:8000

 ## Community

- [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-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)
--- a/bookmarks/admin.py
+++ b/bookmarks/admin.py
@@ -1,17 +1,100 @@
-from django.contrib import admin
+from django.contrib import admin, messages
+from django.contrib.admin import AdminSite
+from django.contrib.auth.admin import UserAdmin
+from django.contrib.auth.models import User
+from django.db.models import Count, QuerySet
+from django.utils.translation import ngettext, gettext
+from rest_framework.authtoken.admin import TokenAdmin
+from rest_framework.authtoken.models import TokenProxy
+
+from bookmarks.models import Bookmark, Tag, UserProfile
+from bookmarks.services.bookmarks import archive_bookmark, unarchive_bookmark
+
+
+class LinkdingAdminSite(AdminSite):
+    site_header = 'linkding administration'
+    site_title = 'linkding Admin'

-from bookmarks.models import Bookmark, Tag

-@admin.register(Bookmark)
 class AdminBookmark(admin.ModelAdmin):
-  list_display = ('title', 'url', 'date_added')
-  search_fields = ('title', 'url', 'tags__name')
-  list_filter = ('tags',)
-  ordering = ('-date_added', )
+    list_display = ('resolved_title', 'url', 'is_archived', 'owner', 'date_added')
+    search_fields = ('title', 'description', 'website_title', 'website_description', 'url', 'tags__name')
+    list_filter = ('owner__username', 'is_archived', 'tags',)
+    ordering = ('-date_added',)
+    actions = ['archive_selected_bookmarks', 'unarchive_selected_bookmarks']
+
+    def archive_selected_bookmarks(self, request, queryset: QuerySet):
+        for bookmark in queryset:
+            archive_bookmark(bookmark)
+        bookmarks_count = queryset.count()
+        self.message_user(request, ngettext(
+            '%d bookmark was successfully archived.',
+            '%d bookmarks were successfully archived.',
+            bookmarks_count,
+        ) % bookmarks_count, messages.SUCCESS)
+
+    def unarchive_selected_bookmarks(self, request, queryset: QuerySet):
+        for bookmark in queryset:
+            unarchive_bookmark(bookmark)
+        bookmarks_count = queryset.count()
+        self.message_user(request, ngettext(
+            '%d bookmark was successfully unarchived.',
+            '%d bookmarks were successfully unarchived.',
+            bookmarks_count,
+        ) % bookmarks_count, messages.SUCCESS)
+

-@admin.register(Tag)
 class AdminTag(admin.ModelAdmin):
-  list_display = ('name', 'date_added', 'owner')
-  search_fields = ('name', 'owner__username')
-  list_filter = ('owner__username', )
-  ordering = ('-date_added', )
+    list_display = ('name', 'bookmarks_count', 'owner', 'date_added')
+    search_fields = ('name', 'owner__username')
+    list_filter = ('owner__username',)
+    ordering = ('-date_added',)
+    actions = ['delete_unused_tags']
+
+    def get_queryset(self, request):
+        queryset = super().get_queryset(request)
+        queryset = queryset.annotate(bookmarks_count=Count("bookmark"))
+        return queryset
+
+    def bookmarks_count(self, obj):
+        return obj.bookmarks_count
+
+    def delete_unused_tags(self, request, queryset: QuerySet):
+        unused_tags = queryset.filter(bookmark__isnull=True)
+        unused_tags_count = unused_tags.count()
+        for tag in unused_tags:
+            tag.delete()
+
+        if unused_tags_count > 0:
+            self.message_user(request, ngettext(
+                '%d unused tag was successfully deleted.',
+                '%d unused tags were successfully deleted.',
+                unused_tags_count,
+            ) % unused_tags_count, messages.SUCCESS)
+        else:
+            self.message_user(request, gettext(
+                'There were no unused tags in the selection',
+            ), messages.SUCCESS)
+
+
+class AdminUserProfileInline(admin.StackedInline):
+    model = UserProfile
+    can_delete = False
+    verbose_name_plural = 'Profile'
+    fk_name = 'user'
+
+
+class AdminCustomUser(UserAdmin):
+    inlines = (AdminUserProfileInline,)
+
+    def get_inline_instances(self, request, obj=None):
+        if not obj:
+            return list()
+        return super(AdminCustomUser, self).get_inline_instances(request, obj)
+
+
+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)
--- a/bookmarks/api/serializers.py
+++ b/bookmarks/api/serializers.py
@@ -30,8 +30,11 @@ class BookmarkSerializer(serializers.ModelSerializer):
            'date_modified'
        ]

+    # Override optional char fields to provide default value
+    title = serializers.CharField(required=False, allow_blank=True, default='')
+    description = serializers.CharField(required=False, allow_blank=True, default='')
    # Override readonly tag_names property to allow passing a list of tag names to create/update
-    tag_names = TagListField()
+    tag_names = TagListField(required=False, default=[])

    def create(self, validated_data):
        bookmark = Bookmark()
--- a/bookmarks/components/SearchAutoComplete.svelte
+++ b/bookmarks/components/SearchAutoComplete.svelte
@@ -264,17 +264,4 @@
        z-index: 2;
    }

-    /* TODO: Should be read from theme */
-    .menu-item.selected > a {
-        background: #f1f1fc;
-        color: #5755d9;
-    }
-
-    .group-item, .group-item:hover {
-        color: #999999;
-        text-transform: uppercase;
-        background: none;
-        font-size: 0.6rem;
-        font-weight: bold;
-    }
 </style>
--- a/bookmarks/components/TagAutocomplete.svelte
+++ b/bookmarks/components/TagAutocomplete.svelte
@@ -4,8 +4,10 @@
    export let id;
    export let name;
    export let value;
-    export let tags;
+    export let apiClient;
+    export let variant = 'default';

+    let tags = [];
    let isFocus = false;
    let isOpen = false;
    let input = null;
@@ -13,6 +15,18 @@
    let suggestions = [];
    let selectedIndex = 0;

+    init();
+
+    async function init() {
+        // For now we cache all tags on load as the template did before
+        try {
+            tags = await apiClient.getTags({limit: 1000, offset: 0});
+            tags.sort((left, right) => left.name.toLowerCase().localeCompare(right.name.toLowerCase()))
+        } catch (e) {
+            console.warn('TagAutocomplete: Error loading tag list');
+        }
+    }
+
    function handleFocus() {
        isFocus = true;
    }
@@ -27,7 +41,9 @@

        const word = getCurrentWord(input);

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

        if (word && suggestions.length > 0) {
            open();
@@ -70,7 +86,7 @@
    function complete(suggestion) {
        const bounds = getCurrentWordBounds(input);
        const value = input.value;
-        input.value = value.substring(0, bounds.start) + suggestion + value.substring(bounds.end);
+        input.value = value.substring(0, bounds.start) + suggestion.name + value.substring(bounds.end);

        close();
    }
@@ -87,11 +103,11 @@
    }
 </script>

-<div class="form-autocomplete">
+<div class="form-autocomplete" class:small={variant === 'small'}>
    <!-- autocomplete input container -->
    <div class="form-autocomplete-input form-input" class:is-focused={isFocus}>
        <!-- autocomplete real input box -->
-        <input id="{id}" name="{name}" value="{value ||''}"
+        <input id="{id}" name="{name}" value="{value ||''}" placeholder="&nbsp;"
               class="form-input" type="text" autocomplete="off"
               on:input={handleInput} on:keydown={handleKeyDown}
               on:focus={handleFocus} on:blur={handleBlur}>
@@ -105,7 +121,7 @@
                <a href="#" on:mousedown|preventDefault={() => complete(tag)}>
                    <div class="tile tile-centered">
                        <div class="tile-content">
-                            {tag}
+                            {tag.name}
                        </div>
                    </div>
                </a>
@@ -125,9 +141,16 @@
        display: block;
    }

-    /* TODO: Should be read from theme */
-    .menu-item.selected > a {
-        background: #f1f1fc;
-        color: #5755d9;
+    .form-autocomplete.small .form-autocomplete-input {
+        height: 1.4rem;
+        min-height: 1.4rem;
    }
-</style>
+    .form-autocomplete.small .form-autocomplete-input input {
+        margin: 0;
+        padding: 0;
+        font-size: 0.7rem;
+    }
+    .form-autocomplete.small .menu .menu-item {
+        font-size: 0.7rem;
+    }
+</style>
--- a/bookmarks/components/api.js
+++ b/bookmarks/components/api.js
@@ -5,7 +5,7 @@ export class ApiClient {

    getBookmarks(query, options = {limit: 100, offset: 0}) {
        const encodedQuery = encodeURIComponent(query)
-        const url = `${this.baseUrl}bookmarks?q=${encodedQuery}&limit=${options.limit}&offset=${options.offset}`
+        const url = `${this.baseUrl}bookmarks/?q=${encodedQuery}&limit=${options.limit}&offset=${options.offset}`

        return fetch(url)
            .then(response => response.json())
@@ -14,7 +14,15 @@ export class ApiClient {

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

        return fetch(url)
            .then(response => response.json())
--- a/bookmarks/migrations/0007_userprofile.py
+++ b/bookmarks/migrations/0007_userprofile.py
@@ -0,0 +1,43 @@
+# Generated by Django 2.2.18 on 2021-03-26 22:39
+
+from django.conf import settings
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+def forwards(apps, schema_editor):
+    User = apps.get_model('auth', 'User')
+    UserProfile = apps.get_model('bookmarks', 'UserProfile')
+    for user in User.objects.all():
+        try:
+            if user.profile:
+                continue
+        except UserProfile.DoesNotExist:
+            profile = UserProfile(user=user)
+            profile.save()
+
+
+def reverse(apps, schema_editor):
+    pass
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+        ('bookmarks', '0006_bookmark_is_archived'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='UserProfile',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('theme',
+                 models.CharField(choices=[('auto', 'Auto'), ('light', 'Light'), ('dark', 'Dark')], default='auto',
+                                  max_length=10)),
+                ('user', models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, related_name='profile',
+                                              to=settings.AUTH_USER_MODEL)),
+            ],
+        ),
+        migrations.RunPython(forwards, reverse),
+    ]
--- a/bookmarks/migrations/0008_userprofile_bookmark_date_display.py
+++ b/bookmarks/migrations/0008_userprofile_bookmark_date_display.py
@@ -0,0 +1,18 @@
+# Generated by Django 2.2.18 on 2021-03-30 10:40
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('bookmarks', '0007_userprofile'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='userprofile',
+            name='bookmark_date_display',
+            field=models.CharField(choices=[('relative', 'Relative'), ('absolute', 'Absolute'), ('hidden', 'Hidden')], default='relative', max_length=10),
+        ),
+    ]
--- a/bookmarks/models.py
+++ b/bookmarks/models.py
@@ -2,7 +2,10 @@ from typing import List

 from django import forms
 from django.contrib.auth import get_user_model
+from django.contrib.auth.models import User
 from django.db import models
+from django.db.models.signals import post_save
+from django.dispatch import receiver

 from bookmarks.utils import unique
 from bookmarks.validators import BookmarkURLValidator
@@ -93,3 +96,43 @@ class BookmarkForm(forms.ModelForm):
    class Meta:
        model = Bookmark
        fields = ['url', 'tag_string', 'title', 'description', 'auto_close', 'return_url']
+
+
+class UserProfile(models.Model):
+    THEME_AUTO = 'auto'
+    THEME_LIGHT = 'light'
+    THEME_DARK = 'dark'
+    THEME_CHOICES = [
+        (THEME_AUTO, 'Auto'),
+        (THEME_LIGHT, 'Light'),
+        (THEME_DARK, 'Dark'),
+    ]
+    BOOKMARK_DATE_DISPLAY_RELATIVE = 'relative'
+    BOOKMARK_DATE_DISPLAY_ABSOLUTE = 'absolute'
+    BOOKMARK_DATE_DISPLAY_HIDDEN = 'hidden'
+    BOOKMARK_DATE_DISPLAY_CHOICES = [
+        (BOOKMARK_DATE_DISPLAY_RELATIVE, 'Relative'),
+        (BOOKMARK_DATE_DISPLAY_ABSOLUTE, 'Absolute'),
+        (BOOKMARK_DATE_DISPLAY_HIDDEN, 'Hidden'),
+    ]
+    user = models.OneToOneField(get_user_model(), related_name='profile', on_delete=models.CASCADE)
+    theme = models.CharField(max_length=10, choices=THEME_CHOICES, blank=False, default=THEME_AUTO)
+    bookmark_date_display = models.CharField(max_length=10, choices=BOOKMARK_DATE_DISPLAY_CHOICES, blank=False,
+                                             default=BOOKMARK_DATE_DISPLAY_RELATIVE)
+
+
+class UserProfileForm(forms.ModelForm):
+    class Meta:
+        model = UserProfile
+        fields = ['theme', 'bookmark_date_display']
+
+
+@receiver(post_save, sender=get_user_model())
+def create_user_profile(sender, instance, created, **kwargs):
+    if created:
+        UserProfile.objects.create(user=instance)
+
+
+@receiver(post_save, sender=get_user_model())
+def save_user_profile(sender, instance, **kwargs):
+    instance.profile.save()
--- a/bookmarks/queries.py
+++ b/bookmarks/queries.py
@@ -55,50 +55,24 @@ def _base_bookmarks_query(user: User, query_string: str) -> QuerySet:
            tags__name__iexact=tag_name
        )

-    # Sort by modification date
-    query_set = query_set.order_by('-date_modified')
+    # Sort by date added
+    query_set = query_set.order_by('-date_added')

    return query_set


 def query_bookmark_tags(user: User, query_string: str) -> QuerySet:
-    return _base_bookmark_tags_query(user, query_string) \
-        .filter(bookmark__is_archived=False) \
-        .distinct()
+    bookmarks_query = query_bookmarks(user, query_string)
+
+    query_set = Tag.objects.filter(bookmark__in=bookmarks_query)
+
+    return query_set.distinct()


 def query_archived_bookmark_tags(user: User, query_string: str) -> QuerySet:
-    return _base_bookmark_tags_query(user, query_string) \
-        .filter(bookmark__is_archived=True) \
-        .distinct()
+    bookmarks_query = query_archived_bookmarks(user, query_string)

-
-def _base_bookmark_tags_query(user: User, query_string: str) -> QuerySet:
-    query_set = Tag.objects
-
-    # Filter for user
-    query_set = query_set.filter(owner=user)
-
-    # Only show tags which have bookmarks
-    query_set = query_set.filter(bookmark__isnull=False)
-
-    # Split query into search terms and tags
-    query = _parse_query_string(query_string)
-
-    # Filter for search terms and tags
-    for term in query['search_terms']:
-        query_set = query_set.filter(
-            Q(bookmark__title__contains=term)
-            | Q(bookmark__description__contains=term)
-            | Q(bookmark__website_title__contains=term)
-            | Q(bookmark__website_description__contains=term)
-            | Q(bookmark__url__contains=term)
-        )
-
-    for tag_name in query['tag_names']:
-        query_set = query_set.filter(
-            bookmark__tags__name__iexact=tag_name
-        )
+    query_set = Tag.objects.filter(bookmark__in=bookmarks_query)

    return query_set.distinct()

--- a/bookmarks/services/bookmarks.py
+++ b/bookmarks/services/bookmarks.py
@@ -1,3 +1,5 @@
+from typing import Union
+
 from django.contrib.auth.models import User
 from django.utils import timezone

@@ -46,6 +48,13 @@ def archive_bookmark(bookmark: Bookmark):
    return bookmark


+def archive_bookmarks(bookmark_ids: [Union[int, str]], current_user: User):
+    sanitized_bookmark_ids = _sanitize_id_list(bookmark_ids)
+    bookmarks = Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids)
+
+    bookmarks.update(is_archived=True, date_modified=timezone.now())
+
+
 def unarchive_bookmark(bookmark: Bookmark):
    bookmark.is_archived = False
    bookmark.date_modified = timezone.now()
@@ -53,6 +62,46 @@ def unarchive_bookmark(bookmark: Bookmark):
    return bookmark


+def unarchive_bookmarks(bookmark_ids: [Union[int, str]], current_user: User):
+    sanitized_bookmark_ids = _sanitize_id_list(bookmark_ids)
+    bookmarks = Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids)
+
+    bookmarks.update(is_archived=False, date_modified=timezone.now())
+
+
+def delete_bookmarks(bookmark_ids: [Union[int, str]], current_user: User):
+    sanitized_bookmark_ids = _sanitize_id_list(bookmark_ids)
+    bookmarks = Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids)
+
+    bookmarks.delete()
+
+
+def tag_bookmarks(bookmark_ids: [Union[int, str]], tag_string: str, current_user: User):
+    sanitized_bookmark_ids = _sanitize_id_list(bookmark_ids)
+    bookmarks = Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids)
+    tag_names = parse_tag_string(tag_string, ' ')
+    tags = get_or_create_tags(tag_names, current_user)
+
+    for bookmark in bookmarks:
+        bookmark.tags.add(*tags)
+        bookmark.date_modified = timezone.now()
+
+    Bookmark.objects.bulk_update(bookmarks, ['date_modified'])
+
+
+def untag_bookmarks(bookmark_ids: [Union[int, str]], tag_string: str, current_user: User):
+    sanitized_bookmark_ids = _sanitize_id_list(bookmark_ids)
+    bookmarks = Bookmark.objects.filter(owner=current_user, id__in=sanitized_bookmark_ids)
+    tag_names = parse_tag_string(tag_string, ' ')
+    tags = get_or_create_tags(tag_names, current_user)
+
+    for bookmark in bookmarks:
+        bookmark.tags.remove(*tags)
+        bookmark.date_modified = timezone.now()
+
+    Bookmark.objects.bulk_update(bookmarks, ['date_modified'])
+
+
 def _merge_bookmark_data(from_bookmark: Bookmark, to_bookmark: Bookmark):
    to_bookmark.title = from_bookmark.title
    to_bookmark.description = from_bookmark.description
@@ -68,3 +117,8 @@ def _update_bookmark_tags(bookmark: Bookmark, tag_string: str, user: User):
    tag_names = parse_tag_string(tag_string, ' ')
    tags = get_or_create_tags(tag_names, user)
    bookmark.tags.set(tags)
+
+
+def _sanitize_id_list(bookmark_ids: [Union[int, str]]) -> [int]:
+    # Convert string ids to int if necessary
+    return [int(bm_id) if isinstance(bm_id, str) else bm_id for bm_id in bookmark_ids]
--- a/bookmarks/services/importer.py
+++ b/bookmarks/services/importer.py
@@ -1,12 +1,13 @@
 import logging
 from dataclasses import dataclass
-from datetime import datetime

 from django.contrib.auth.models import User
+from django.utils import timezone

 from bookmarks.models import Bookmark, parse_tag_string
 from bookmarks.services.parser import parse, NetscapeBookmark
 from bookmarks.services.tags import get_or_create_tags
+from bookmarks.utils import parse_timestamp

 logger = logging.getLogger(__name__)

@@ -45,7 +46,10 @@ def _import_bookmark_tag(netscape_bookmark: NetscapeBookmark, user: User):
    bookmark = _get_or_create_bookmark(netscape_bookmark.href, user)

    bookmark.url = netscape_bookmark.href
-    bookmark.date_added = datetime.utcfromtimestamp(int(netscape_bookmark.date_added)).astimezone()
+    if netscape_bookmark.date_added:
+        bookmark.date_added = parse_timestamp(netscape_bookmark.date_added)
+    else:
+        bookmark.date_added = timezone.now()
    bookmark.date_modified = bookmark.date_added
    bookmark.unread = False
    bookmark.title = netscape_bookmark.title
@@ -53,6 +57,7 @@ def _import_bookmark_tag(netscape_bookmark: NetscapeBookmark, user: User):
        bookmark.description = netscape_bookmark.description
    bookmark.owner = user

+    bookmark.full_clean()
    bookmark.save()

    # Set tags
--- a/bookmarks/services/parser.py
+++ b/bookmarks/services/parser.py
@@ -1,5 +1,4 @@
 from dataclasses import dataclass
-from datetime import datetime

 import pyparsing as pp

@@ -9,7 +8,7 @@ class NetscapeBookmark:
    href: str
    title: str
    description: str
-    date_added: int
+    date_added: str
    tag_string: str


@@ -17,8 +16,7 @@ def extract_bookmark_link(tag):
    href = tag[0].href
    title = tag[0].text
    tag_string = tag[0].tags
-    date_added_string = tag[0].add_date if tag[0].add_date else datetime.now().timestamp()
-    date_added = int(date_added_string)
+    date_added = tag[0].add_date

    return {
        'href': href,
--- a/bookmarks/services/website_loader.py
+++ b/bookmarks/services/website_loader.py
@@ -2,6 +2,7 @@ from dataclasses import dataclass

 import requests
 from bs4 import BeautifulSoup
+from charset_normalizer import from_bytes


@dataclass
@@ -33,5 +34,11 @@ def load_website_metadata(url: str):


 def load_page(url: str):
-    r = requests.get(url)
-    return r.text
+    r = requests.get(url, timeout=10)
+
+    # Use charset_normalizer to determine encoding that best matches the response content
+    # Several sites seem to specify the response encoding incorrectly, so we ignore it and use custom logic instead
+    # This is different from Response.text which does respect the encoding specified in the response first,
+    # before trying to determine one
+    results = from_bytes(r.content)
+    return str(results.best())
--- a/bookmarks/static/bulk_edit.js
+++ b/bookmarks/static/bulk_edit.js
@@ -0,0 +1,86 @@
+(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();
+})()
--- a/bookmarks/static/logo.png
+++ b/bookmarks/static/logo.png
--- a/bookmarks/static/shared.js
+++ b/bookmarks/static/shared.js
@@ -0,0 +1,45 @@
+(function () {
+
+    function initConfirmationButtons() {
+        const buttonEls = document.querySelectorAll('.btn-confirmation');
+
+        function showConfirmation(buttonEl) {
+            const cancelEl = document.createElement(buttonEl.nodeName);
+            cancelEl.innerText = 'Cancel';
+            cancelEl.className = 'btn btn-link btn-sm btn-confirmation-action mr-1';
+            cancelEl.addEventListener('click', function () {
+                container.remove();
+                buttonEl.style = '';
+            });
+
+            const confirmEl = document.createElement(buttonEl.nodeName);
+            confirmEl.innerText = 'Confirm';
+            confirmEl.className = 'btn btn-link btn-delete btn-sm btn-confirmation-action';
+
+            if (buttonEl.nodeName === 'BUTTON') {
+                confirmEl.type = buttonEl.type;
+                confirmEl.name = buttonEl.name;
+            }
+            if (buttonEl.nodeName === 'A') {
+                confirmEl.href = buttonEl.href;
+            }
+
+            const container = document.createElement('span');
+            container.className = 'confirmation'
+            container.appendChild(cancelEl);
+            container.appendChild(confirmEl);
+            buttonEl.parentElement.insertBefore(container, buttonEl);
+            buttonEl.style = 'display: none';
+        }
+
+        buttonEls.forEach(function (linkEl) {
+            linkEl.addEventListener('click', function (e) {
+                e.preventDefault();
+                showConfirmation(linkEl);
+            });
+        });
+    }
+
+
+    initConfirmationButtons()
+})()
--- a/bookmarks/styles/base.scss
+++ b/bookmarks/styles/base.scss
@@ -1,5 +1,10 @@
 body {
  margin: 20px 10px;
+
+  @media (min-width: $size-sm) {
+    // High horizontal padding accounts for checkboxes that show up in bulk edit mode
+    margin: 20px 24px;
+  }
 }

 header {
@@ -10,20 +15,22 @@ header {

  .navbar-brand {

+    display: flex;
+    align-items: center;
+
    .logo {
-      background-color: $primary-color;
-      color: $light-color;
-      padding: 14px;
+      width: 28px;
+      height: 28px;
    }

    h1 {
      text-transform: uppercase;
      display: inline-block;
+      margin: 0 0 0 8px;
    }
  }

  .dropdown-toggle {
-    padding: 0;
  }
 }

@@ -39,9 +46,18 @@ h2 {
  color: $gray-color-dark;
 }

-// Button color should not change for anchor elements
-.btn:visited:not(.btn-primary) {
-  color: $primary-color;
+// Fix up visited styles
+a:visited {
+  color: $link-color;
+}
+a:visited:hover {
+  color: $link-color-dark;
+}
+.btn-link:visited:not(.btn-primary) {
+  color: $link-color;
+}
+.btn-link:visited:not(.btn-primary):hover {
+  color: $link-color-dark;
 }

 // Increase spacing between columns
@@ -52,4 +68,25 @@ h2 {
 // Remove left padding from first pagination link
 .pagination .page-item:first-child a {
  padding-left: 0;
-}
+}
+
+// Override border color for tab block
+.tab-block {
+  border-bottom: solid 1px $border-color;
+}
+
+// Form auto-complete menu
+.form-autocomplete .menu {
+  .menu-item.selected > a, .menu-item > a:hover {
+    background: $secondary-color;
+    color: $primary-color;
+  }
+
+  .group-item, .group-item:hover {
+    color: $gray-color;
+    text-transform: uppercase;
+    background: none;
+    font-size: 0.6rem;
+    font-weight: bold;
+  }
+}
--- a/bookmarks/styles/bookmarks.scss
+++ b/bookmarks/styles/bookmarks.scss
@@ -30,6 +30,12 @@
  }
 }

+.bookmarks-page .content-area-header {
+  span.btn {
+    margin-left: 8px;
+  }
+}
+
 ul.bookmark-list {

  list-style: none;
@@ -39,29 +45,32 @@ ul.bookmark-list {
  .description {
    color: $gray-color-dark;

-    a {
+    a, a:visited:hover {
      color: $alternative-color;
    }
  }

+  .actions > *:not(:last-child) {
+    margin-right: 0.1rem;
+  }
+
  .actions .btn-link {
    color: $gray-color;
-    padding-left: 0;
-    padding-right: 0;
+    padding: 0;
+    height: auto;
+    vertical-align: unset;
+    border: none;

    &:focus,
    &:hover,
    &:active,
    &.active {
-      color: darken($gray-color, 10%);
+      color: $gray-color-dark;
    }
  }

-  .actions .btn-link.bm-remove-confirm {
-    color: $error-color;
-    &:hover {
-      text-decoration: underline;
-    }
+  .bulk-edit-toggle {
+    display: none;
  }
 }

@@ -71,7 +80,7 @@ ul.bookmark-list {

 .tag-cloud {

-  a {
+  a, a:visited:hover {
    color: $alternative-color;
  }

@@ -88,12 +97,41 @@ ul.bookmark-list {

 .bookmarks-form {

+  .btn.form-icon {
+    padding: 0;
+    width: 20px;
+    height: 20px;
+    visibility: hidden;
+    color: $gray-color;
+
+    &:focus,
+    &:hover,
+    &:active,
+    &.active {
+      color: $gray-color-dark;
+    }
+
+    > svg {
+      width: 20px;
+      height: 20px;
+    }
+  }
+
+  .has-icon-right > input, .has-icon-right > textarea {
+    padding-right: 30px;
+  }
+
+  .has-icon-right > input:placeholder-shown ~ .btn.form-icon,
+  .has-icon-right > textarea:placeholder-shown ~ .btn.form-icon {
+    visibility: visible;
+  }
+
  .form-icon.loading {
    visibility: hidden;
  }

  .form-input-hint.bookmark-exists {
-    visibility: hidden;
+    display: none;
    color: $warning-color;

    a {
@@ -103,3 +141,101 @@ ul.bookmark-list {
    }
  }
 }
+
+/* Bulk edit */
+$bulk-edit-toggle-width: 16px;
+$bulk-edit-toggle-offset: 8px;
+$bulk-edit-bar-offset: $bulk-edit-toggle-width + (2 * $bulk-edit-toggle-offset);
+$bulk-edit-transition-duration: 400ms;
+
+.bulk-edit-form {
+
+  .bulk-edit-bar {
+    margin-top: -17px;
+    margin-bottom: 16px;
+    margin-left: -$bulk-edit-bar-offset;
+    max-height: 0;
+    overflow: hidden;
+    transition: max-height $bulk-edit-transition-duration;
+  }
+
+  .bulk-edit-actions {
+    display: flex;
+    align-items: baseline;
+    padding: 4px 0;
+    border-top: solid 1px $border-color;
+
+    button:hover {
+      text-decoration: underline;
+    }
+
+    > label.form-checkbox {
+      min-height: 1rem;
+    }
+
+    > button {
+      padding: 0;
+      margin-left: 8px;
+    }
+
+    > span {
+      margin-left: 8px;
+    }
+
+    > input, .form-autocomplete {
+      width: auto;
+      margin-left: 4px;
+      max-width: 200px;
+      -webkit-appearance: none;
+    }
+
+    span.confirmation {
+      display: flex;
+    }
+
+    span.confirmation button {
+      padding: 0;
+    }
+  }
+
+  .bulk-edit-all-toggle {
+    width: $bulk-edit-toggle-width;
+    margin: 0 0 0 $bulk-edit-toggle-offset;
+    padding: 0;
+  }
+
+  ul.bookmark-list li {
+    position: relative;
+  }
+
+  ul.bookmark-list li .bulk-edit-toggle {
+    display: block;
+    position: absolute;
+    width: $bulk-edit-toggle-width;
+    left: -$bulk-edit-toggle-width - $bulk-edit-toggle-offset;
+    top: 0;
+    padding: 0;
+    margin: 0;
+    visibility: hidden;
+    opacity: 0;
+    transition: all $bulk-edit-transition-duration;
+
+    i {
+      top: 0.2rem;
+    }
+  }
+}
+
+#bulk-edit-mode {
+  display: none;
+}
+
+#bulk-edit-mode:checked ~ .bookmarks-page .bulk-edit-toggle {
+  visibility: visible;
+  opacity: 1;
+}
+
+#bulk-edit-mode:checked ~ .bookmarks-page .bulk-edit-bar {
+  max-height: 37px;
+  border-bottom: solid 1px $border-color;
+}
--- a/bookmarks/styles/dark.scss
+++ b/bookmarks/styles/dark.scss
@@ -0,0 +1,32 @@
+/* Dark theme overrides */
+
+/* Buttons */
+.btn.btn-primary {
+  background: $dt-primary-button-color;
+  border-color: darken($dt-primary-button-color, 5%);
+
+  &:hover, &:active, &:focus {
+    background: darken($dt-primary-button-color, 5%);
+    border-color: darken($dt-primary-button-color, 10%);
+  }
+}
+
+/* Focus ring*/
+a:focus, .btn:focus {
+  box-shadow: 0 0 0 .1rem rgba($primary-color, .5);
+}
+
+/* Forms */
+.has-error .form-input, .form-input.is-error, .has-error .form-select, .form-select.is-error {
+  background: darken($error-color, 40%);
+}
+
+.form-checkbox input:checked + .form-icon, .form-radio input:checked + .form-icon, .form-switch input:checked + .form-icon {
+  background: $dt-primary-button-color;
+  border-color: $dt-primary-button-color;
+}
+
+/* Pagination */
+.pagination .page-item.active a {
+  background: $dt-primary-button-color;
+}
--- a/bookmarks/styles/index.scss
+++ b/bookmarks/styles/index.scss
@@ -1,27 +0,0 @@
-// Font sizes
-$html-font-size: 18px !default;
-
-//$alternative-color: #c84e00;
-//$alternative-color: #FF84E8;
-//$alternative-color: #98C1D9;
-//$alternative-color: #7B287D;
-$alternative-color: #05a6a3;
-$alternative-color-dark: darken($alternative-color, 5%);
-
-// Import Spectre CSS lib
-@import "../../node_modules/spectre.css/src/spectre";
-@import "../../node_modules/spectre.css/src/autocomplete";
-// Import Spectre icons
-@import "../../node_modules/spectre.css/src/icons/icons-core";
-@import "../../node_modules/spectre.css/src/icons/icons-navigation";
-@import "../../node_modules/spectre.css/src/icons/icons-action";
-@import "../../node_modules/spectre.css/src/icons/icons-object";
-
-
-// Import style modules
-@import "base";
-@import "util";
-@import "shared";
-@import "bookmarks";
-@import "settings";
-@import "auth";
--- a/bookmarks/styles/settings.scss
+++ b/bookmarks/styles/settings.scss
@@ -1,6 +1,11 @@
 .settings-page {
  section.content-area {
    margin-bottom: 2rem;
+
+    h2 {
+      font-size: 1.0rem;
+      margin-bottom: 0.8rem;
+    }
  }

  .input-group > input[type=submit] {
--- a/bookmarks/styles/shared.scss
+++ b/bookmarks/styles/shared.scss
@@ -1,3 +1,4 @@
+// Content area component
 section.content-area {

  .content-area-header {
@@ -11,3 +12,11 @@ section.content-area {
    }
  }
 }
+
+// Confirm button component
+.btn-confirmation-action {
+  color: $error-color !important;
+  &:hover {
+    text-decoration: underline;
+  }
+}
--- a/bookmarks/styles/theme-dark.scss
+++ b/bookmarks/styles/theme-dark.scss
@@ -0,0 +1,17 @@
+// Import custom variables
+@import "variables-dark";
+
+// Import Spectre CSS lib
+@import "../../node_modules/spectre.css/src/spectre";
+@import "../../node_modules/spectre.css/src/autocomplete";
+
+// Import style modules
+@import "base";
+@import "util";
+@import "shared";
+@import "bookmarks";
+@import "settings";
+@import "auth";
+
+// Dark theme overrides
+@import "dark";
--- a/bookmarks/styles/theme-light.scss
+++ b/bookmarks/styles/theme-light.scss
@@ -0,0 +1,14 @@
+// Import custom variables
+@import "variables-light";
+
+// Import Spectre CSS lib
+@import "../../node_modules/spectre.css/src/spectre";
+@import "../../node_modules/spectre.css/src/autocomplete";
+
+// Import style modules
+@import "base";
+@import "util";
+@import "shared";
+@import "bookmarks";
+@import "settings";
+@import "auth";
--- a/bookmarks/styles/util.scss
+++ b/bookmarks/styles/util.scss
@@ -7,3 +7,11 @@
  overflow: hidden;
  text-overflow: ellipsis;
 }
+
+.text-sm {
+  font-size: 0.7rem;
+}
+
+.text-gray-dark {
+  color: $gray-color-dark;
+}
--- a/bookmarks/styles/variables-dark.scss
+++ b/bookmarks/styles/variables-dark.scss
@@ -0,0 +1,28 @@
+$html-font-size: 18px !default;
+
+$body-bg: #161822 !default;
+$bg-color: lighten($body-bg, 5%) !default;
+$bg-color-light: lighten($body-bg, 5%) !default;
+
+$border-color: #4C4E53 !default;
+$border-color-dark: $border-color !default;
+
+$body-font-color: #b5bec8 !default;
+$light-color: #fafafa !default;
+
+$gray-color: #7f879b !default;
+$gray-color-dark: lighten($gray-color, 20%) !default;
+
+$primary-color: #a8b1ff !default;
+$primary-color-dark: saturate($primary-color, 5%) !default;
+$secondary-color: lighten($body-bg, 10%) !default;
+
+$link-color: $primary-color !default;
+$link-color-dark: darken($link-color, 5%) !default;
+$link-color-light: $link-color !default;
+
+$alternative-color: #59bdb9;
+$alternative-color-dark: #73f1eb;
+
+/* Dark theme specific */
+$dt-primary-button-color: #5761cb !default;
--- a/bookmarks/styles/variables-light.scss
+++ b/bookmarks/styles/variables-light.scss
@@ -0,0 +1,4 @@
+$html-font-size: 18px !default;
+
+$alternative-color: #05a6a3;
+$alternative-color-dark: darken($alternative-color, 5%);
--- a/bookmarks/templates/bookmarks/archive.html
+++ b/bookmarks/templates/bookmarks/archive.html
@@ -4,6 +4,9 @@
 {% load bookmarks %}

 {% block content %}
+
+    {% include 'bookmarks/bulk_edit/state.html' %}
+
    <div class="bookmarks-page columns">

        {# Bookmark list #}
@@ -12,13 +15,20 @@
                <h2>Archived bookmarks</h2>
                <div class="spacer"></div>
                {% bookmark_search query tags mode='archive' %}
+                {% include 'bookmarks/bulk_edit/toggle.html' %}
            </div>

-            {% if empty %}
-                {% include 'bookmarks/empty_bookmarks.html' %}
-            {% else %}
-                {% bookmark_list bookmarks return_url %}
-            {% endif %}
+            <form class="bulk-edit-form" action="{% url 'bookmarks:bulk_edit' %}?return_url={{ return_url }}"
+                  method="post">
+                {% csrf_token %}
+                {% include 'bookmarks/bulk_edit/bar.html' with mode='archive' %}
+
+                {% if empty %}
+                    {% include 'bookmarks/empty_bookmarks.html' %}
+                {% else %}
+                    {% bookmark_list bookmarks return_url %}
+                {% endif %}
+            </form>
        </section>

        {# Tag list #}
@@ -31,4 +41,6 @@
    </div>

    <script src="{% static "bundle.js" %}"></script>
+    <script src="{% static "shared.js" %}"></script>
+    <script src="{% static "bulk_edit.js" %}"></script>
 {% endblock %}
--- a/bookmarks/templates/bookmarks/bookmark_list.html
+++ b/bookmarks/templates/bookmarks/bookmark_list.html
@@ -3,17 +3,21 @@

 <ul class="bookmark-list">
    {% for bookmark in bookmarks %}
-        <li>
+        <li data-is-bookmark-item>
+            <label class="form-checkbox bulk-edit-toggle">
+                <input type="checkbox" name="bookmark_id" value="{{ bookmark.id }}">
+                <i class="form-icon"></i>
+            </label>
            <div class="title truncate">
                <a href="{{ bookmark.url }}" target="_blank" rel="noopener">{{ bookmark.resolved_title }}</a>
            </div>
            <div class="description truncate">
                {% if bookmark.tag_names %}
                    <span>
-                        {% for tag_name in bookmark.tag_names %}
-                            <a href="?{% append_query_param q=tag_name|hash_tag %}">{{ tag_name|hash_tag }}</a>
-                        {% endfor %}
-                    </span>
+                            {% for tag_name in bookmark.tag_names %}
+                                <a href="?{% append_query_param q=tag_name|hash_tag %}">{{ tag_name|hash_tag }}</a>
+                            {% endfor %}
+                        </span>
                {% endif %}
                {% if bookmark.tag_names and bookmark.resolved_description %} | {% endif %}

@@ -22,6 +26,14 @@
                {% endif %}
            </div>
            <div class="actions">
+                {% if request.user.profile.bookmark_date_display == 'relative' %}
+                    <span class="text-gray text-sm">{{ bookmark.date_added|humanize_relative_date }}</span>
+                    <span class="text-gray text-sm">|</span>
+                {% endif %}
+                {% if request.user.profile.bookmark_date_display == 'absolute' %}
+                    <span class="text-gray text-sm">{{ bookmark.date_added|humanize_absolute_date }}</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 %}
@@ -32,7 +44,7 @@
                       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 bm-remove">Remove</a>
+                   class="btn btn-link btn-sm btn-confirmation">Remove</a>
            </div>
        </li>
    {% endfor %}
@@ -41,38 +53,3 @@
 <div class="bookmark-pagination">
    {% pagination bookmarks %}
 </div>
-
-{# Enhance delete links to show inline confirmation #}
-<script type="application/javascript">
-    window.addEventListener("load", function () {
-        const linkEls = document.querySelectorAll('.bookmark-list a.bm-remove');
-
-        function showConfirmation(linkEl) {
-            const cancelEl = document.createElement('span');
-            cancelEl.innerText = 'Cancel';
-            cancelEl.className = 'btn btn-link btn-sm bm-remove-confirm mr-1';
-            cancelEl.addEventListener('click', function() {
-                container.remove();
-                linkEl.style = '';
-            });
-
-            const confirmEl = document.createElement('a');
-            confirmEl.innerText = 'Confirm';
-            confirmEl.className = 'btn btn-link btn-delete btn-sm bm-remove-confirm';
-            confirmEl.href = linkEl.href;
-
-            const container = document.createElement('span');
-            container.appendChild(cancelEl);
-            container.appendChild(confirmEl);
-            linkEl.parentElement.appendChild(container);
-            linkEl.style = 'display: none';
-        }
-
-        linkEls.forEach(function (linkEl) {
-            linkEl.addEventListener('click', function (e) {
-                e.preventDefault();
-                showConfirmation(linkEl);
-            });
-        });
-    });
-</script>
--- a/bookmarks/templates/bookmarks/bulk_edit/bar.html
+++ b/bookmarks/templates/bookmarks/bulk_edit/bar.html
@@ -0,0 +1,31 @@
+<div class="bulk-edit-bar">
+    <div class="bulk-edit-actions bg-gray">
+        <label class="form-checkbox bulk-edit-all-toggle">
+            <input type="checkbox" style="display: none">
+            <i class="form-icon"></i>
+        </label>
+        {% if mode == 'archive' %}
+            <button type="submit" name="bulk_unarchive" class="btn btn-link btn-sm btn-confirmation"
+                    title="Unarchive selected bookmarks">Unarchive
+            </button>
+        {% else %}
+            <button type="submit" name="bulk_archive" class="btn btn-link btn-sm btn-confirmation"
+                    title="Archive selected bookmarks">Archive
+            </button>
+        {% endif %}
+        <span class="text-sm text-gray-dark">•</span>
+        <button type="submit" name="bulk_delete" class="btn btn-link btn-sm btn-confirmation"
+                title="Delete selected bookmarks">Delete
+        </button>
+        <span class="text-sm text-gray-dark">•</span>
+        <span class="text-sm text-gray-dark"><label for="bulk-edit-tags-input">Tags:</label></span>
+        <input id="bulk-edit-tags-input" name="bulk_tag_string" class="form-input input-sm"
+               placeholder="&nbsp;">
+        <button type="submit" name="bulk_tag" class="btn btn-link btn-sm"
+                title="Add tags to selected bookmarks">Add
+        </button>
+        <button type="submit" name="bulk_untag" class="btn btn-link btn-sm"
+                title="Remove tags from selected bookmarks">Remove
+        </button>
+    </div>
+</div>
--- a/bookmarks/templates/bookmarks/bulk_edit/state.html
+++ b/bookmarks/templates/bookmarks/bulk_edit/state.html
@@ -0,0 +1 @@
+<input id="bulk-edit-mode" type="checkbox">
--- a/bookmarks/templates/bookmarks/bulk_edit/toggle.html
+++ b/bookmarks/templates/bookmarks/bulk_edit/toggle.html
@@ -0,0 +1,8 @@
+<label for="bulk-edit-mode" class="hide-sm">
+    <span class="btn" title="Bulk edit">
+        <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20" fill="currentColor" width="20px"
+             height="20px">
+            <path d="M7 3a1 1 0 000 2h6a1 1 0 100-2H7zM4 7a1 1 0 011-1h10a1 1 0 110 2H5a1 1 0 01-1-1zM2 11a2 2 0 012-2h12a2 2 0 012 2v4a2 2 0 01-2 2H4a2 2 0 01-2-2v-4z"/>
+        </svg>
+    </span>
+</label>
--- a/bookmarks/templates/bookmarks/edit.html
+++ b/bookmarks/templates/bookmarks/edit.html
@@ -8,7 +8,7 @@
                <h2>Edit bookmark</h2>
            </div>
            <form action="{% url 'bookmarks:edit' bookmark_id %}" method="post" class="col-6 col-md-12" novalidate>
-                {% bookmark_form form all_tags return_url bookmark_id %}
+                {% bookmark_form form return_url bookmark_id %}
            </form>
        </section>
    </div>
--- a/bookmarks/templates/bookmarks/empty_bookmarks.html
+++ b/bookmarks/templates/bookmarks/empty_bookmarks.html
@@ -2,7 +2,7 @@
    <p class="empty-title h5">You have no bookmarks yet</p>
    <p class="empty-subtitle">
        You can get started by <a href="{% url 'bookmarks:new' %}">adding</a> bookmarks,
-        <a href="{% url 'bookmarks:settings.index' %}">importing</a> your existing bookmarks or configuring the
-        <a href="{% url 'bookmarks:settings.index' %}#bookmarklet">bookmarklet</a>.
+        <a href="{% url 'bookmarks:settings.general' %}">importing</a> your existing bookmarks or configuring the
+        <a href="{% url 'bookmarks:settings.integrations' %}">browser extension</a> or the <a href="{% url 'bookmarks:settings.integrations' %}">bookmarklet</a>.
    </p>
 </div>
--- a/bookmarks/templates/bookmarks/form.html
+++ b/bookmarks/templates/bookmarks/form.html
@@ -7,19 +7,20 @@
    {{ form.return_url|attr:"type:hidden" }}
    <div class="form-group {% if form.url.errors %}has-error{% endif %}">
        <label for="{{ form.url.id_for_label }}" class="form-label">URL</label>
-        {{ form.url|add_class:"form-input"|attr:"autofocus" }}
+        {{ form.url|add_class:"form-input"|attr:"autofocus"|attr:"placeholder: " }}
        {% if form.url.errors %}
            <div class="form-input-hint">
                {{ form.url.errors }}
            </div>
        {% endif %}
        <div class="form-input-hint bookmark-exists">
-            This URL is already bookmarked. You can <a href="#">edit</a> it or you can overwrite the existing bookmark by saving this form.
+            This URL is already bookmarked. You can <a href="#">edit</a> it or you can overwrite the existing bookmark
+            by saving this form.
        </div>
    </div>
    <div class="form-group">
        <label for="{{ form.tag_string.id_for_label }}" class="form-label">Tags</label>
-        {{ form.tag_string|add_class:"form-input" }}
+        {{ form.tag_string|add_class:"form-input"|attr:"autocomplete:off" }}
        <div class="form-input-hint">
            Enter any number of tags separated by space and <strong>without</strong> the hash (#). If a tag does not
            exist it will be
@@ -30,8 +31,16 @@
    <div class="form-group has-icon-right">
        <label for="{{ form.title.id_for_label }}" class="form-label">Title</label>
        <div class="has-icon-right">
-            {{ form.title|add_class:"form-input" }}
+            {{ form.title|add_class:"form-input"|attr:"autocomplete:off" }}
            <i class="form-icon loading"></i>
+            <a class="btn btn-link form-icon" title="Edit title from website">
+                <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20" fill="currentColor">
+                    <path d="M17.414 2.586a2 2 0 00-2.828 0L7 10.172V13h2.828l7.586-7.586a2 2 0 000-2.828z"/>
+                    <path fill-rule="evenodd"
+                          d="M2 6a2 2 0 012-2h4a1 1 0 010 2H4v10h10v-4a1 1 0 112 0v4a2 2 0 01-2 2H4a2 2 0 01-2-2V6z"
+                          clip-rule="evenodd"/>
+                </svg>
+            </a>
        </div>
        <div class="form-input-hint">
            Optional, leave empty to use title from website.
@@ -43,6 +52,14 @@
        <div class="has-icon-right">
            {{ form.description|add_class:"form-input"|attr:"rows:4" }}
            <i class="form-icon loading"></i>
+            <a class="btn btn-link form-icon" title="Edit description from website">
+                <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20" fill="currentColor">
+                    <path d="M17.414 2.586a2 2 0 00-2.828 0L7 10.172V13h2.828l7.586-7.586a2 2 0 000-2.828z"/>
+                    <path fill-rule="evenodd"
+                          d="M2 6a2 2 0 012-2h4a1 1 0 010 2H4v10h10v-4a1 1 0 112 0v4a2 2 0 01-2 2H4a2 2 0 01-2-2V6z"
+                          clip-rule="evenodd"/>
+                </svg>
+            </a>
        </div>
        <div class="form-input-hint">
            Optional, leave empty to use description from website.
@@ -64,8 +81,7 @@
    <script type="application/javascript">
        const wrapper = document.createElement('div');
        const tagInput = document.getElementById('{{ form.tag_string.id_for_label }}');
-        const allTagsString = '{{ all_tags }}';
-        const allTags = allTagsString.split(' ');
+        const apiClient = new linkding.ApiClient('{% url 'bookmarks:api-root' %}')

        new linkding.TagAutoComplete({
            target: wrapper,
@@ -73,7 +89,7 @@
                id: '{{ form.tag_string.id_for_label }}',
                name: '{{ form.tag_string.name }}',
                value: tagInput.value,
-                tags: allTags
+                apiClient: apiClient
            }
        });

@@ -83,49 +99,72 @@
        /**
         * - Pre-fill title and description placeholders with metadata from website as soon as URL changes
         * - Show hint if URL is already bookmarked
+         * - Setup buttons that allow editing of scraped website values
         */
        (function init() {
            const urlInput = document.getElementById('{{ form.url.id_for_label }}');
            const titleInput = document.getElementById('{{ form.title.id_for_label }}');
            const descriptionInput = document.getElementById('{{ form.description.id_for_label }}');
-            const editedBookmarkId = {{ bookmark_id }}
+            const editedBookmarkId = {{ bookmark_id }};

-            urlInput.addEventListener('input', checkUrl);
+            function toggleLoadingIcon(input, show) {
+                const icon = input.parentNode.querySelector('i.form-icon');
+                icon.style['visibility'] = show ? 'visible' : 'hidden';
+            }
+
+            function updatePlaceholder(input, value) {
+                if (value) {
+                    input.setAttribute('placeholder', value);
+                } else {
+                    input.removeAttribute('placeholder');
+                }
+            }

            function checkUrl() {
-                toggleIcon(titleInput, true);
-                toggleIcon(descriptionInput, true);
+                toggleLoadingIcon(titleInput, true);
+                toggleLoadingIcon(descriptionInput, true);
+                updatePlaceholder(titleInput, null);
+                updatePlaceholder(descriptionInput, null);

                const websiteUrl = encodeURIComponent(urlInput.value);
                const requestUrl = `{% url 'bookmarks:api-root' %}bookmarks/check?url=${websiteUrl}`;
                fetch(requestUrl)
                    .then(response => response.json())
                    .then(data => {
-                        const metadata = data.metadata
-                        titleInput.setAttribute('placeholder', metadata.title || '');
-                        descriptionInput.setAttribute('placeholder', metadata.description || '');
-                        toggleIcon(titleInput, false);
-                        toggleIcon(descriptionInput, false);
+                        const metadata = data.metadata;
+                        updatePlaceholder(titleInput, metadata.title);
+                        updatePlaceholder(descriptionInput, metadata.description);
+                        toggleLoadingIcon(titleInput, false);
+                        toggleLoadingIcon(descriptionInput, false);

                        // Display hint if URL is already bookmarked
-                        const bookmarkExistsHint = document.querySelector('.form-input-hint.bookmark-exists')
-                        const editExistingBookmarkLink = bookmarkExistsHint.querySelector('a')
+                        const bookmarkExistsHint = document.querySelector('.form-input-hint.bookmark-exists');
+                        const editExistingBookmarkLink = bookmarkExistsHint.querySelector('a');

-                        if(data.bookmark && data.bookmark.id !== editedBookmarkId) {
-                            bookmarkExistsHint.style['visibility'] = 'visible'
-                            editExistingBookmarkLink.href = data.bookmark.edit_url
+                        if (data.bookmark && data.bookmark.id !== editedBookmarkId) {
+                            bookmarkExistsHint.style['display'] = 'block';
+                            editExistingBookmarkLink.href = data.bookmark.edit_url;
                        } else {
-                            bookmarkExistsHint.style['visibility'] = 'hidden'
+                            bookmarkExistsHint.style['display'] = 'none';
                        }
                    });
            }

-            function toggleIcon(input, show) {
-                const icon = input.parentNode.querySelector('i.form-icon');
-                icon.style['visibility'] = show ? 'visible' : 'hidden';
+            function setupEditAutoValueButton(input) {
+                const editAutoValueButton = input.parentNode.querySelector('.btn.form-icon');
+                if (!editAutoValueButton) return;
+                editAutoValueButton.addEventListener('click', function (event) {
+                    event.preventDefault();
+                    input.value = input.getAttribute('placeholder');
+                    input.focus();
+                    input.select();
+                });
            }

            if (urlInput.value) checkUrl();
+            urlInput.addEventListener('input', checkUrl);
+            setupEditAutoValueButton(titleInput);
+            setupEditAutoValueButton(descriptionInput);
        })();
    </script>
 </div>
--- a/bookmarks/templates/bookmarks/index.html
+++ b/bookmarks/templates/bookmarks/index.html
@@ -4,6 +4,9 @@
 {% load bookmarks %}

 {% block content %}
+
+    {% include 'bookmarks/bulk_edit/state.html' %}
+
    <div class="bookmarks-page columns">

        {# Bookmark list #}
@@ -12,13 +15,20 @@
                <h2>Bookmarks</h2>
                <div class="spacer"></div>
                {% bookmark_search query tags %}
+                {% include 'bookmarks/bulk_edit/toggle.html' %}
            </div>

-            {% if empty %}
-                {% include 'bookmarks/empty_bookmarks.html' %}
-            {% else %}
-                {% bookmark_list bookmarks return_url %}
-            {% endif %}
+            <form class="bulk-edit-form" action="{% url 'bookmarks:bulk_edit' %}?return_url={{ return_url }}"
+                  method="post">
+                {% csrf_token %}
+                {% include 'bookmarks/bulk_edit/bar.html' with mode='default' %}
+
+                {% if empty %}
+                    {% include 'bookmarks/empty_bookmarks.html' %}
+                {% else %}
+                    {% bookmark_list bookmarks return_url %}
+                {% endif %}
+            </form>
        </section>

        {# Tag list #}
@@ -31,4 +41,6 @@
    </div>

    <script src="{% static "bundle.js" %}"></script>
+    <script src="{% static "shared.js" %}"></script>
+    <script src="{% static "bulk_edit.js" %}"></script>
 {% endblock %}
--- a/bookmarks/templates/bookmarks/layout.html
+++ b/bookmarks/templates/bookmarks/layout.html
@@ -2,7 +2,8 @@
 {% load sass_tags %}

 <!DOCTYPE html>
-<html lang="en">
+{# Use data attributes as storage for access in static scripts #}
+<html lang="en" data-api-base-url="{% url 'bookmarks:api-root' %}">
 <head>
    <meta charset="UTF-8">
    <link rel="icon" href="{% static 'favicon.png' %}"/>
@@ -12,14 +13,24 @@
    <meta name="author" content="Sascha Ißbrücker">
    <title>linkding</title>
    {# Include SASS styles, files are resolved from bookmarks/styles #}
-    <link href="{% sass_src 'index.scss' %}" rel="stylesheet" type="text/css"/>
+    {# Include specific theme variant based on user profile setting #}
+    {% if request.user.profile.theme == 'light' %}
+        <link href="{% sass_src 'theme-light.scss' %}" rel="stylesheet" type="text/css"/>
+    {% elif request.user.profile.theme == 'dark' %}
+        <link href="{% sass_src 'theme-dark.scss' %}" rel="stylesheet" type="text/css"/>
+    {% else %}
+        {# Use auto theme as fallback #}
+        <link href="{% sass_src 'theme-dark.scss' %}" rel="stylesheet" type="text/css"
+              media="(prefers-color-scheme: dark)"/>
+        <link href="{% sass_src 'theme-light.scss' %}" rel="stylesheet" type="text/css"
+              media="(prefers-color-scheme: light)"/>
+    {% endif %}
 </head>
 <body>
 <header class="navbar container grid-lg">
    <section class="navbar-section">
        <a href="/" class="navbar-brand text-bold">
-            <i class="logo icon icon-link s-circle"></i>
-
+            <img class="logo" src="{% static 'logo.png' %}" alt="Application logo">
            <h1>linkding</h1>
        </a>
    </section>
--- a/bookmarks/templates/bookmarks/nav_menu.html
+++ b/bookmarks/templates/bookmarks/nav_menu.html
@@ -7,12 +7,16 @@
 </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 href="{% url 'bookmarks:new' %}" class="btn btn-primary">
+        <svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke="currentColor" style="width: 24px; height: 24px">
+            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 6v6m0 0v6m0-6h6m-6 0H6" />
+        </svg>
    </a>
    <div class="dropdown dropdown-right">
        <a href="#" id="mobile-nav-menu-trigger" class="btn btn-link dropdown-toggle" tabindex="0">
-            <i class="icon icon-menu icon-2x"></i>
+            <svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke="currentColor" style="width: 24px; height: 24px">
+                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M4 6h16M4 12h16M4 18h16" />
+            </svg>
        </a>
        <!-- menu component -->
        <ul class="menu">
@@ -46,4 +50,4 @@
    mobileNavMenuTrigger.addEventListener('blur', function () {
        document.removeEventListener('click', mobileNavMenuOutsideClickHandler);
    })
-</script>
+</script>
--- a/bookmarks/templates/bookmarks/new.html
+++ b/bookmarks/templates/bookmarks/new.html
@@ -8,7 +8,7 @@
                <h2>New bookmark</h2>
            </div>
            <form action="{% url 'bookmarks:new' %}" method="post" class="col-6 col-md-12" novalidate>
-                {% bookmark_form form all_tags return_url auto_close=auto_close %}
+                {% bookmark_form form return_url auto_close=auto_close %}
            </form>
        </section>
    </div>
--- a/bookmarks/templates/bookmarks/tag_cloud.html
+++ b/bookmarks/templates/bookmarks/tag_cloud.html
@@ -7,13 +7,13 @@
                {# Highlight first char of first tag in group #}
                {% if forloop.counter == 1 %}
                    <a href="?{% append_query_param q=tag.name|hash_tag %}"
-                       class="mr-2">
+                       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">
+                       class="mr-2" data-is-tag-item>
                        <span>{{ tag.name }}</span>
                    </a>
                {% endif %}
--- a/bookmarks/templates/registration/login.html
+++ b/bookmarks/templates/registration/login.html
@@ -20,11 +20,11 @@
                    {% endif %}
                    <div class="form-group">
                        <label class="form-label" for="{{ form.username.id_for_label }}">Username</label>
-                        {{ form.username|add_class:'form-input' }}
+                        {{ form.username|add_class:'form-input'|attr:"placeholder: " }}
                    </div>
                    <div class="form-group">
                        <label class="form-label" for="{{ form.password.id_for_label }}">Password</label>
-                        {{ form.password|add_class:'form-input' }}
+                        {{ form.password|add_class:'form-input'|attr:"placeholder: " }}
                    </div>

                    <br/>
--- a/bookmarks/templates/settings/api.html
+++ b/bookmarks/templates/settings/api.html
@@ -0,0 +1,25 @@
+{% extends "bookmarks/layout.html" %}
+
+{% block content %}
+    <div class="settings-page">
+
+        {% include 'settings/nav.html' %}
+
+        <section class="content-area">
+            <h2>API Token</h2>
+            <p>The following token can be used to authenticate 3rd-party applications against the REST API:</p>
+            <div class="form-group">
+                <div class="columns">
+                    <div class="column col-6 col-md-12">
+                        <input class="form-input" value="{{ api_token }}" disabled>
+                    </div>
+                </div>
+            </div>
+            <p><strong>Please treat this token as you would any other credential.</strong> Any party with access to this
+                token can access and manage all your bookmarks.</p>
+            <p>If you think that a token was compromised you can revoke (delete) it in the <a href="{% url 'admin:authtoken_tokenproxy_changelist' %}">admin panel</a>. After deleting the token, a new one will be generated when you reload this settings page.</p>
+        </section>
+
+    </div>
+
+{% endblock %}
--- a/bookmarks/templates/settings/general.html
+++ b/bookmarks/templates/settings/general.html
@@ -1,13 +1,33 @@
 {% extends "bookmarks/layout.html" %}
+{% load widget_tweaks %}

 {% block content %}
    <div class="settings-page">

+        {% include 'settings/nav.html' %}
+
+        {# Profile section #}
+        <section class="content-area">
+            <h2>Profile</h2>
+            <form action="{% url 'bookmarks:settings.general' %}" method="post" novalidate>
+                {% csrf_token %}
+                <div class="form-group">
+                    <label for="{{ form.theme.id_for_label }}" class="form-label">Theme</label>
+                    {{ form.theme|add_class:"form-select col-2 col-sm-12" }}
+                </div>
+                <div class="form-group">
+                    <label for="{{ form.bookmark_date_display.id_for_label }}" class="form-label">Bookmark date format</label>
+                    {{ form.bookmark_date_display|add_class:"form-select col-2 col-sm-12" }}
+                </div>
+                <div class="form-group">
+                    <input type="submit" value="Save" class="btn btn-primary mt-2">
+                </div>
+            </form>
+        </section>
+
        {# Import section #}
        <section class="content-area">
-            <div class="content-area-header">
-                <h2>Import</h2>
-            </div>
+            <h2>Import</h2>
            <p>Import bookmarks and tags in the Netscape HTML format. This will execute a sync where new bookmarks are
                added and existing ones are updated.</p>
            <form method="post" enctype="multipart/form-data" action="{% url 'bookmarks:settings.import' %}">
@@ -37,9 +57,7 @@

        {# Export section #}
        <section class="content-area">
-            <div class="content-area-header">
-                <h2>Export</h2>
-            </div>
+            <h2>Export</h2>
            <p>Export all bookmarks in Netscape HTML format.</p>
            <a class="btn btn-primary" href="{% url 'bookmarks:settings.export' %}">Download (.html)</a>
            {% if export_error %}
@@ -51,41 +69,15 @@
            {% endif %}
        </section>

-        {# Integrations section #}
+        {# About 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>
+            <h2>About</h2>
+            <p>Version: {{ app_version }}</p>
+            <p>
+                Code: <a href="https://github.com/sissbruecker/linkding/"
+                    target="_blank">GitHub</a>
+            </p>
        </section>
-
-        {# API token section #}
-        <section class="content-area">
-            <div class="content-area-header">
-                <h2>API Token</h2>
-            </div>
-            <p>The following token can be used to authenticate 3rd-party applications against the REST API:</p>
-            <div class="form-group">
-                <div class="columns">
-                    <div class="column col-6 col-md-12">
-                        <input class="form-input" value="{{ api_token }}" disabled>
-                    </div>
-                </div>
-            </div>
-            <p><strong>Please treat this token as you would any other credential.</strong> Any party with access to this token can access and manage all your bookmarks.</p>
-        </section>
-
    </div>

 {% endblock %}
--- a/bookmarks/templates/settings/integrations.html
+++ b/bookmarks/templates/settings/integrations.html
@@ -0,0 +1,33 @@
+{% extends "bookmarks/layout.html" %}
+
+{% block content %}
+    <div class="settings-page">
+
+        {% include 'settings/nav.html' %}
+
+        {# Integrations section #}
+        <section class="content-area">
+            <h2>Browser Extension</h2>
+            <p>The browser extension allows you to quickly add new bookmarks without leaving the page that you are on. The extension is available in the official extension stores for:</p>
+            <ul>
+                <li><a href="https://addons.mozilla.org/de/firefox/addon/linkding-extension/" target="_blank">Firefox</a></li>
+                <li><a href="https://chrome.google.com/webstore/detail/linkding-extension/beakmhbijpdhipnjhnclmhgjlddhidpe" target="_blank">Chrome</a></li>
+            </ul>
+            <p>The extension is <a href="https://github.com/sissbruecker/linkding-extension" target="_blank">open source</a> as well, which enables you to build and manually load it into any browser that supports Chrome extensions.</p>
+            <h2>Bookmarklet</h2>
+            <p>The bookmarklet is an alternative, cross-browser way to quickly add new bookmarks without opening the linkding application
+                first. Here's how it works:</p>
+            <ul>
+                <li>Drag the bookmarklet below into your browsers bookmark bar / toolbar</li>
+                <li>Open the website that you want to bookmark</li>
+                <li>Click the bookmarklet in your browsers toolbar</li>
+                <li>linkding opens in a new window or tab and allows you to add a bookmark for the site</li>
+                <li>After saving the bookmark the linkding window closes and you are back on your website</li>
+            </ul>
+            <p>Drag the following bookmarklet to your browsers toolbar:</p>
+            <a href="javascript: {% include 'bookmarks/bookmarklet.js' %}"
+               class="btn btn-primary">📎 Add bookmark</a>
+        </section>
+
+    </div>
+{% endblock %}
--- a/bookmarks/templates/settings/nav.html
+++ b/bookmarks/templates/settings/nav.html
@@ -0,0 +1,26 @@
+{% url 'bookmarks:settings.index' as index_url %}
+{% url 'bookmarks:settings.general' as general_url %}
+{% url 'bookmarks:settings.integrations' as integrations_url %}
+{% url 'bookmarks:settings.api' as api_url %}
+
+<ul class="tab tab-block">
+    <li class="tab-item {% if request.get_full_path == index_url or request.get_full_path == general_url%}active{% endif %}">
+        <a href="{% url 'bookmarks:settings.general' %}">General</a>
+    </li>
+    <li class="tab-item {% if request.get_full_path == integrations_url %}active{% endif %}">
+        <a href="{% url 'bookmarks:settings.integrations' %}">Integrations</a>
+    </li>
+    <li class="tab-item {% if request.get_full_path == api_url %}active{% endif %}">
+        <a href="{% url 'bookmarks:settings.api' %}">API</a>
+    </li>
+    <li class="tab-item tooltip tooltip-bottom" data-tooltip="The admin panel provides additional features &#010; such as user management and bulk operations.">
+        <a href="{% url 'admin:index' %}" target="_blank">
+            <span>Admin</span>
+            <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20" fill="currentColor" class="ml-1" style="width: 1.2em; height: 1.2em; vertical-align: -0.2em;">
+                <path d="M11 3a1 1 0 100 2h2.586l-6.293 6.293a1 1 0 101.414 1.414L15 6.414V9a1 1 0 102 0V4a1 1 0 00-1-1h-5z" />
+                <path d="M5 5a2 2 0 00-2 2v8a2 2 0 002 2h8a2 2 0 002-2v-3a1 1 0 10-2 0v3H5V7h3a1 1 0 000-2H5z" />
+            </svg>
+        </a>
+    </li>
+</ul>
+<br>
--- a/bookmarks/templatetags/bookmarks.py
+++ b/bookmarks/templatetags/bookmarks.py
@@ -9,15 +9,10 @@ register = template.Library()


@register.inclusion_tag('bookmarks/form.html', name='bookmark_form')
-def bookmark_form(form: BookmarkForm, all_tags: List[Tag], cancel_url: str, bookmark_id: int = 0, auto_close: bool = False):
-
-    all_tag_names = [tag.name for tag in all_tags]
-    all_tags_string = build_tag_string(all_tag_names, ' ')
-
+def bookmark_form(form: BookmarkForm, cancel_url: str, bookmark_id: int = 0, auto_close: bool = False):
    return {
        'form': form,
        'auto_close': auto_close,
-        'all_tags': all_tags_string,
        'bookmark_id': bookmark_id,
        'cancel_url': cancel_url
    }
@@ -58,6 +53,7 @@ def tag_cloud(context, tags: List[Tag]):
@register.inclusion_tag('bookmarks/bookmark_list.html', name='bookmark_list', takes_context=True)
 def bookmark_list(context, bookmarks: Page, return_url: str):
    return {
+        'request': context['request'],
        'bookmarks': bookmarks,
        'return_url': return_url
    }
--- a/bookmarks/templatetags/shared.py
+++ b/bookmarks/templatetags/shared.py
@@ -1,5 +1,7 @@
 from django import template

+from bookmarks import utils
+
 register = template.Library()


@@ -43,3 +45,17 @@ def first_char(text):
@register.filter(name='remaining_chars')
 def remaining_chars(text, index):
    return text[index:]
+
+
+@register.filter(name='humanize_absolute_date')
+def humanize_absolute_date(value):
+    if value in (None, ''):
+        return ''
+    return utils.humanize_absolute_date(value)
+
+
+@register.filter(name='humanize_relative_date')
+def humanize_relative_date(value):
+    if value in (None, ''):
+        return ''
+    return utils.humanize_relative_date(value)
--- a/bookmarks/tests/helpers.py
+++ b/bookmarks/tests/helpers.py
@@ -0,0 +1,131 @@
+import random
+import logging
+
+from django.contrib.auth.models import User
+from django.utils import timezone
+from django.utils.crypto import get_random_string
+from rest_framework import status
+from rest_framework.test import APITestCase
+
+from bookmarks.models import Bookmark, Tag
+
+
+class BookmarkFactoryMixin:
+    user = None
+
+    def get_or_create_test_user(self):
+        if self.user is None:
+            self.user = User.objects.create_user('testuser', 'test@example.com', 'password123')
+
+        return self.user
+
+    def setup_bookmark(self,
+                       is_archived: bool = False,
+                       tags=None,
+                       user: User = None,
+                       url: str = '',
+                       title: str = '',
+                       description: str = '',
+                       website_title: str = '',
+                       website_description: str = '',
+                       ):
+        if tags is None:
+            tags = []
+        if user is None:
+            user = self.get_or_create_test_user()
+        if not url:
+            unique_id = get_random_string(length=32)
+            url = 'https://example.com/' + unique_id
+        bookmark = Bookmark(
+            url=url,
+            title=title,
+            description=description,
+            website_title=website_title,
+            website_description=website_description,
+            date_added=timezone.now(),
+            date_modified=timezone.now(),
+            owner=user,
+            is_archived=is_archived
+        )
+        bookmark.save()
+        for tag in tags:
+            bookmark.tags.add(tag)
+        bookmark.save()
+        return bookmark
+
+    def setup_tag(self, user: User = None, name: str = ''):
+        if user is None:
+            user = self.get_or_create_test_user()
+        if not name:
+            name = get_random_string(length=32)
+        tag = Tag(name=name, date_added=timezone.now(), owner=user)
+        tag.save()
+        return tag
+
+
+class LinkdingApiTestCase(APITestCase):
+    def get(self, url, expected_status_code=status.HTTP_200_OK):
+        response = self.client.get(url)
+        self.assertEqual(response.status_code, expected_status_code)
+        return response
+
+    def post(self, url, data=None, expected_status_code=status.HTTP_200_OK):
+        response = self.client.post(url, data, format='json')
+        self.assertEqual(response.status_code, expected_status_code)
+        return response
+
+    def put(self, url, data=None, expected_status_code=status.HTTP_200_OK):
+        response = self.client.put(url, data, format='json')
+        self.assertEqual(response.status_code, expected_status_code)
+        return response
+
+    def delete(self, url, expected_status_code=status.HTTP_200_OK):
+        response = self.client.delete(url)
+        self.assertEqual(response.status_code, expected_status_code)
+        return response
+
+
+_words = [
+    'quasi',
+    'consequatur',
+    'necessitatibus',
+    'debitis',
+    'quod',
+    'vero',
+    'qui',
+    'commodi',
+    'quod',
+    'odio',
+    'aliquam',
+    'veniam',
+    'architecto',
+    'consequatur',
+    'autem',
+    'qui',
+    'iste',
+    'asperiores',
+    'soluta',
+    'et',
+]
+
+
+def random_sentence(num_words: int = None, including_word: str = ''):
+    if num_words is None:
+        num_words = random.randint(5, 10)
+    selected_words = random.choices(_words, k=num_words)
+    if including_word:
+        selected_words.append(including_word)
+    random.shuffle(selected_words)
+
+    return ' '.join(selected_words)
+
+
+def disable_logging(f):
+    def wrapper(*args):
+        logging.disable(logging.CRITICAL)
+        result = f(*args)
+        logging.disable(logging.NOTSET)
+
+        return result
+
+    return wrapper
--- a/bookmarks/tests/resources/invalid_import_file.png
+++ b/bookmarks/tests/resources/invalid_import_file.png
--- a/bookmarks/tests/resources/simple_valid_import_file.html
+++ b/bookmarks/tests/resources/simple_valid_import_file.html
@@ -0,0 +1,20 @@
+<!DOCTYPE NETSCAPE-Bookmark-file-1>
+
+<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8">
+
+<TITLE>Bookmarks</TITLE>
+
+<H1>Bookmarks</H1>
+
+<DL><p>
+
+    <DT><A HREF="https://example.com/1" ADD_DATE="1616337559" PRIVATE="0" TOREAD="0" TAGS="tag1">test title 1</A>
+    <DD>test description 1
+
+    <DT><A HREF="https://example.com/2" ADD_DATE="1616337559000" PRIVATE="0" TOREAD="0" TAGS="tag2">test title 2</A>
+    <DD>test description 2
+
+    <DT><A HREF="https://example.com/3" ADD_DATE="1616337559000000" PRIVATE="0" TOREAD="0" TAGS="tag3">test title 3</A>
+    <DD>test description 3
+
+</DL><p>
--- a/bookmarks/tests/resources/simple_valid_import_file_with_one_invalid_bookmark.html
+++ b/bookmarks/tests/resources/simple_valid_import_file_with_one_invalid_bookmark.html
@@ -0,0 +1,20 @@
+<!DOCTYPE NETSCAPE-Bookmark-file-1>
+
+<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8">
+
+<TITLE>Bookmarks</TITLE>
+
+<H1>Bookmarks</H1>
+
+<DL><p>
+
+    <DT><A HREF="https://example.com/1" ADD_DATE="invaliddate" PRIVATE="0" TOREAD="0" TAGS="tag1">test title 1</A>
+    <DD>test description 1
+
+    <DT><A HREF="https://example.com/2" ADD_DATE="1616337559" PRIVATE="0" TOREAD="0" TAGS="tag2">test title 2</A>
+    <DD>test description 2
+
+    <DT><A HREF="https://example.com/3" ADD_DATE="1616337559" PRIVATE="0" TOREAD="0" TAGS="tag3">test title 3</A>
+    <DD>test description 3
+
+</DL><p>
--- a/bookmarks/tests/test_bookmark_archive_view.py
+++ b/bookmarks/tests/test_bookmark_archive_view.py
@@ -0,0 +1,35 @@
+from django.test import TestCase
+from django.urls import reverse
+
+from bookmarks.tests.helpers import BookmarkFactoryMixin
+
+
+class BookmarkArchiveViewTestCase(TestCase, BookmarkFactoryMixin):
+
+    def setUp(self) -> None:
+        user = self.get_or_create_test_user()
+        self.client.force_login(user)
+
+    def test_should_archive_bookmark(self):
+        bookmark = self.setup_bookmark()
+
+        self.client.get(reverse('bookmarks:archive', args=[bookmark.id]))
+        bookmark.refresh_from_db()
+
+        self.assertTrue(bookmark.is_archived)
+
+    def test_should_redirect_to_index(self):
+        bookmark = self.setup_bookmark()
+
+        response = self.client.get(reverse('bookmarks:archive', args=[bookmark.id]))
+
+        self.assertRedirects(response, reverse('bookmarks:index'))
+
+    def test_should_redirect_to_return_url_when_specified(self):
+        bookmark = self.setup_bookmark()
+
+        response = self.client.get(
+            reverse('bookmarks:archive', args=[bookmark.id]) + '?return_url=' + reverse('bookmarks:close')
+        )
+
+        self.assertRedirects(response, reverse('bookmarks:close'))
--- a/bookmarks/tests/test_bookmark_archived_view.py
+++ b/bookmarks/tests/test_bookmark_archived_view.py
@@ -0,0 +1,132 @@
+from django.contrib.auth.models import User
+from django.test import TestCase
+from django.urls import reverse
+
+from bookmarks.models import Bookmark, Tag
+from bookmarks.tests.helpers import BookmarkFactoryMixin
+
+
+class BookmarkArchivedViewTestCase(TestCase, BookmarkFactoryMixin):
+
+    def setUp(self) -> None:
+        user = self.get_or_create_test_user()
+        self.client.force_login(user)
+
+    def assertVisibleBookmarks(self, response, bookmarks: [Bookmark]):
+        html = response.content.decode()
+        self.assertContains(response, 'data-is-bookmark-item', count=len(bookmarks))
+
+        for bookmark in bookmarks:
+            self.assertInHTML(
+                '<a href="{0}" target="_blank" rel="noopener">{1}</a>'.format(bookmark.url, bookmark.resolved_title),
+                html
+            )
+
+    def assertInvisibleBookmarks(self, response, bookmarks: [Bookmark]):
+        html = response.content.decode()
+
+        for bookmark in bookmarks:
+            self.assertInHTML(
+                '<a href="{0}" target="_blank" rel="noopener">{1}</a>'.format(bookmark.url, bookmark.resolved_title),
+                html,
+                count=0
+            )
+
+    def assertVisibleTags(self, response, tags: [Tag]):
+        self.assertContains(response, 'data-is-tag-item', count=len(tags))
+
+        for tag in tags:
+            self.assertContains(response, tag.name)
+
+    def assertInvisibleTags(self, response, tags: [Tag]):
+        for tag in tags:
+            self.assertNotContains(response, tag.name)
+
+    def test_should_list_archived_and_user_owned_bookmarks(self):
+        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
+        visible_bookmarks = [
+            self.setup_bookmark(is_archived=True),
+            self.setup_bookmark(is_archived=True),
+            self.setup_bookmark(is_archived=True)
+        ]
+        invisible_bookmarks = [
+            self.setup_bookmark(is_archived=False),
+            self.setup_bookmark(is_archived=True, user=other_user),
+        ]
+
+        response = self.client.get(reverse('bookmarks:archived'))
+
+        self.assertContains(response, '<ul class="bookmark-list">')  # Should render list
+        self.assertVisibleBookmarks(response, visible_bookmarks)
+        self.assertInvisibleBookmarks(response, invisible_bookmarks)
+
+    def test_should_list_bookmarks_matching_query(self):
+        visible_bookmarks = [
+            self.setup_bookmark(is_archived=True, title='searchvalue'),
+            self.setup_bookmark(is_archived=True, title='searchvalue'),
+            self.setup_bookmark(is_archived=True, title='searchvalue')
+        ]
+        invisible_bookmarks = [
+            self.setup_bookmark(is_archived=True),
+            self.setup_bookmark(is_archived=True),
+            self.setup_bookmark(is_archived=True)
+        ]
+
+        response = self.client.get(reverse('bookmarks:archived') + '?q=searchvalue')
+
+        self.assertContains(response, '<ul class="bookmark-list">')  # Should render list
+        self.assertVisibleBookmarks(response, visible_bookmarks)
+        self.assertInvisibleBookmarks(response, invisible_bookmarks)
+
+    def test_should_list_tags_for_archived_and_user_owned_bookmarks(self):
+        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
+        visible_tags = [
+            self.setup_tag(),
+            self.setup_tag(),
+            self.setup_tag(),
+        ]
+        invisible_tags = [
+            self.setup_tag(),  # unused tag
+            self.setup_tag(),  # used in archived bookmark
+            self.setup_tag(user=other_user),  # belongs to other user
+        ]
+
+        # Assign tags to some bookmarks with duplicates
+        self.setup_bookmark(is_archived=True, tags=[visible_tags[0]])
+        self.setup_bookmark(is_archived=True, tags=[visible_tags[0]])
+        self.setup_bookmark(is_archived=True, tags=[visible_tags[1]])
+        self.setup_bookmark(is_archived=True, tags=[visible_tags[1]])
+        self.setup_bookmark(is_archived=True, tags=[visible_tags[2]])
+        self.setup_bookmark(is_archived=True, tags=[visible_tags[2]])
+
+        self.setup_bookmark(is_archived=False, tags=[invisible_tags[1]])
+        self.setup_bookmark(is_archived=True, tags=[invisible_tags[2]], user=other_user)
+
+        response = self.client.get(reverse('bookmarks:archived'))
+
+        self.assertVisibleTags(response, visible_tags)
+        self.assertInvisibleTags(response, invisible_tags)
+
+    def test_should_list_tags_for_bookmarks_matching_query(self):
+        visible_tags = [
+            self.setup_tag(),
+            self.setup_tag(),
+            self.setup_tag(),
+        ]
+        invisible_tags = [
+            self.setup_tag(),
+            self.setup_tag(),
+            self.setup_tag(),
+        ]
+
+        self.setup_bookmark(is_archived=True, tags=[visible_tags[0]], title='searchvalue'),
+        self.setup_bookmark(is_archived=True, tags=[visible_tags[1]], title='searchvalue')
+        self.setup_bookmark(is_archived=True, tags=[visible_tags[2]], title='searchvalue')
+        self.setup_bookmark(is_archived=True, tags=[invisible_tags[0]])
+        self.setup_bookmark(is_archived=True, tags=[invisible_tags[1]])
+        self.setup_bookmark(is_archived=True, tags=[invisible_tags[2]])
+
+        response = self.client.get(reverse('bookmarks:archived') + '?q=searchvalue')
+
+        self.assertVisibleTags(response, visible_tags)
+        self.assertInvisibleTags(response, invisible_tags)
--- a/bookmarks/tests/test_bookmark_bulk_edit_view.py
+++ b/bookmarks/tests/test_bookmark_bulk_edit_view.py
@@ -0,0 +1,132 @@
+from django.forms import model_to_dict
+from django.test import TestCase
+from django.urls import reverse
+
+from bookmarks.models import Bookmark
+from bookmarks.tests.helpers import BookmarkFactoryMixin
+
+
+class BookmarkBulkEditViewTestCase(TestCase, BookmarkFactoryMixin):
+
+    def setUp(self) -> None:
+        user = self.get_or_create_test_user()
+        self.client.force_login(user)
+
+    def assertBookmarksAreUnmodified(self, bookmarks: [Bookmark]):
+        self.assertEqual(len(bookmarks), Bookmark.objects.count())
+
+        for bookmark in bookmarks:
+            self.assertEqual(model_to_dict(bookmark), model_to_dict(Bookmark.objects.get(id=bookmark.id)))
+
+    def test_bulk_archive(self):
+        bookmark1 = self.setup_bookmark()
+        bookmark2 = self.setup_bookmark()
+        bookmark3 = self.setup_bookmark()
+
+        self.client.post(reverse('bookmarks:bulk_edit'), {
+            'bulk_archive': [''],
+            'bookmark_id': [str(bookmark1.id), str(bookmark2.id), str(bookmark3.id)],
+        })
+
+        self.assertTrue(Bookmark.objects.get(id=bookmark1.id).is_archived)
+        self.assertTrue(Bookmark.objects.get(id=bookmark2.id).is_archived)
+        self.assertTrue(Bookmark.objects.get(id=bookmark3.id).is_archived)
+
+    def test_bulk_unarchive(self):
+        bookmark1 = self.setup_bookmark(is_archived=True)
+        bookmark2 = self.setup_bookmark(is_archived=True)
+        bookmark3 = self.setup_bookmark(is_archived=True)
+
+        self.client.post(reverse('bookmarks:bulk_edit'), {
+            'bulk_unarchive': [''],
+            'bookmark_id': [str(bookmark1.id), str(bookmark2.id), str(bookmark3.id)],
+        })
+
+        self.assertFalse(Bookmark.objects.get(id=bookmark1.id).is_archived)
+        self.assertFalse(Bookmark.objects.get(id=bookmark2.id).is_archived)
+        self.assertFalse(Bookmark.objects.get(id=bookmark3.id).is_archived)
+
+    def test_bulk_delete(self):
+        bookmark1 = self.setup_bookmark()
+        bookmark2 = self.setup_bookmark()
+        bookmark3 = self.setup_bookmark()
+
+        self.client.post(reverse('bookmarks:bulk_edit'), {
+            'bulk_delete': [''],
+            'bookmark_id': [str(bookmark1.id), str(bookmark2.id), str(bookmark3.id)],
+        })
+
+        self.assertIsNone(Bookmark.objects.filter(id=bookmark1.id).first())
+        self.assertFalse(Bookmark.objects.filter(id=bookmark2.id).first())
+        self.assertFalse(Bookmark.objects.filter(id=bookmark3.id).first())
+
+    def test_bulk_tag(self):
+        bookmark1 = self.setup_bookmark()
+        bookmark2 = self.setup_bookmark()
+        bookmark3 = self.setup_bookmark()
+        tag1 = self.setup_tag()
+        tag2 = self.setup_tag()
+
+        self.client.post(reverse('bookmarks:bulk_edit'), {
+            'bulk_tag': [''],
+            'bulk_tag_string': [f'{tag1.name} {tag2.name}'],
+            'bookmark_id': [str(bookmark1.id), str(bookmark2.id), str(bookmark3.id)],
+        })
+
+        bookmark1.refresh_from_db()
+        bookmark2.refresh_from_db()
+        bookmark3.refresh_from_db()
+
+        self.assertCountEqual(bookmark1.tags.all(), [tag1, tag2])
+        self.assertCountEqual(bookmark2.tags.all(), [tag1, tag2])
+        self.assertCountEqual(bookmark3.tags.all(), [tag1, tag2])
+
+    def test_bulk_untag(self):
+        tag1 = self.setup_tag()
+        tag2 = self.setup_tag()
+        bookmark1 = self.setup_bookmark(tags=[tag1, tag2])
+        bookmark2 = self.setup_bookmark(tags=[tag1, tag2])
+        bookmark3 = self.setup_bookmark(tags=[tag1, tag2])
+
+        self.client.post(reverse('bookmarks:bulk_edit'), {
+            'bulk_untag': [''],
+            'bulk_tag_string': [f'{tag1.name} {tag2.name}'],
+            'bookmark_id': [str(bookmark1.id), str(bookmark2.id), str(bookmark3.id)],
+        })
+
+        bookmark1.refresh_from_db()
+        bookmark2.refresh_from_db()
+        bookmark3.refresh_from_db()
+
+        self.assertCountEqual(bookmark1.tags.all(), [])
+        self.assertCountEqual(bookmark2.tags.all(), [])
+        self.assertCountEqual(bookmark3.tags.all(), [])
+
+    def test_bulk_edit_handles_empty_bookmark_id(self):
+        bookmark1 = self.setup_bookmark()
+        bookmark2 = self.setup_bookmark()
+        bookmark3 = self.setup_bookmark()
+
+        response = self.client.post(reverse('bookmarks:bulk_edit'), {
+            'bulk_archive': [''],
+        })
+        self.assertEqual(response.status_code, 302)
+
+        response = self.client.post(reverse('bookmarks:bulk_edit'), {
+            'bulk_archive': [''],
+            'bookmark_id': [],
+        })
+        self.assertEqual(response.status_code, 302)
+
+        self.assertBookmarksAreUnmodified([bookmark1, bookmark2, bookmark3])
+
+    def test_empty_action_does_not_modify_bookmarks(self):
+        bookmark1 = self.setup_bookmark()
+        bookmark2 = self.setup_bookmark()
+        bookmark3 = self.setup_bookmark()
+
+        self.client.post(reverse('bookmarks:bulk_edit'), {
+            'bookmark_id': [str(bookmark1.id), str(bookmark2.id), str(bookmark3.id)],
+        })
+
+        self.assertBookmarksAreUnmodified([bookmark1, bookmark2, bookmark3])
--- a/bookmarks/tests/test_bookmark_edit_view.py
+++ b/bookmarks/tests/test_bookmark_edit_view.py
@@ -0,0 +1,97 @@
+from django.test import TestCase
+from django.urls import reverse
+
+from bookmarks.models import build_tag_string
+from bookmarks.tests.helpers import BookmarkFactoryMixin
+
+
+class BookmarkEditViewTestCase(TestCase, BookmarkFactoryMixin):
+
+    def setUp(self) -> None:
+        user = self.get_or_create_test_user()
+        self.client.force_login(user)
+
+    def create_form_data(self, overrides=None):
+        if overrides is None:
+            overrides = {}
+        form_data = {
+            'url': 'http://example.com/edited',
+            'tag_string': 'editedtag1 editedtag2',
+            'title': 'edited title',
+            'description': 'edited description',
+            'return_url': reverse('bookmarks:index'),
+        }
+        return {**form_data, **overrides}
+
+    def test_should_edit_bookmark(self):
+        bookmark = self.setup_bookmark()
+        form_data = self.create_form_data({'id': bookmark.id})
+
+        self.client.post(reverse('bookmarks:edit', args=[bookmark.id]), form_data)
+
+        bookmark.refresh_from_db()
+
+        self.assertEqual(bookmark.owner, self.user)
+        self.assertEqual(bookmark.url, form_data['url'])
+        self.assertEqual(bookmark.title, form_data['title'])
+        self.assertEqual(bookmark.description, form_data['description'])
+        self.assertEqual(bookmark.tags.count(), 2)
+        self.assertEqual(bookmark.tags.all()[0].name, 'editedtag1')
+        self.assertEqual(bookmark.tags.all()[1].name, 'editedtag2')
+
+    def test_should_use_bookmark_index_as_default_return_url(self):
+        bookmark = self.setup_bookmark()
+
+        response = self.client.get(reverse('bookmarks:edit', args=[bookmark.id]))
+        html = response.content.decode()
+
+        self.assertInHTML(
+            '<input type="hidden" name="return_url" value="{0}" '
+            'id="id_return_url">'.format(reverse('bookmarks:index')),
+            html)
+
+    def test_should_prefill_bookmark_form_fields(self):
+        tag1 = self.setup_tag()
+        tag2 = self.setup_tag()
+        bookmark = self.setup_bookmark(tags=[tag1, tag2], title='edited title', description='edited description')
+
+        response = self.client.get(reverse('bookmarks:edit', args=[bookmark.id]))
+        html = response.content.decode()
+
+        self.assertInHTML('<input type="text" name="url" '
+                          'value="{0}" placeholder=" " '
+                          'autofocus class="form-input" required '
+                          'id="id_url">'.format(bookmark.url),
+                          html)
+
+        tag_string = build_tag_string(bookmark.tag_names, ' ')
+        self.assertInHTML('<input type="text" name="tag_string" '
+                          'value="{0}" autocomplete="off" '
+                          'class="form-input" '
+                          'id="id_tag_string">'.format(tag_string),
+                          html)
+
+        self.assertInHTML('<input type="text" name="title" maxlength="512" '
+                          'autocomplete="off" class="form-input" '
+                          'value="{0}" id="id_title">'.format(bookmark.title),
+                          html)
+
+        self.assertInHTML('<textarea name="description" cols="40" rows="4" class="form-input" id="id_description">{0}'
+                          '</textarea>'.format(bookmark.description),
+                          html)
+
+    def test_should_prefill_return_url_from_url_parameter(self):
+        bookmark = self.setup_bookmark()
+
+        response = self.client.get(reverse('bookmarks:edit', args=[bookmark.id]) + '?return_url=/test-return-url')
+        html = response.content.decode()
+
+        self.assertInHTML('<input type="hidden" name="return_url" value="/test-return-url" id="id_return_url">', html)
+
+    def test_should_redirect_to_return_url(self):
+        bookmark = self.setup_bookmark()
+        form_data = self.create_form_data({'return_url': reverse('bookmarks:close')})
+
+        response = self.client.post(reverse('bookmarks:edit', args=[bookmark.id]), form_data)
+
+        self.assertRedirects(response, form_data['return_url'])
--- a/bookmarks/tests/test_bookmark_index_view.py
+++ b/bookmarks/tests/test_bookmark_index_view.py
@@ -0,0 +1,132 @@
+from django.contrib.auth.models import User
+from django.test import TestCase
+from django.urls import reverse
+
+from bookmarks.models import Bookmark, Tag
+from bookmarks.tests.helpers import BookmarkFactoryMixin
+
+
+class BookmarkIndexViewTestCase(TestCase, BookmarkFactoryMixin):
+
+    def setUp(self) -> None:
+        user = self.get_or_create_test_user()
+        self.client.force_login(user)
+
+    def assertVisibleBookmarks(self, response, bookmarks: [Bookmark]):
+        html = response.content.decode()
+        self.assertContains(response, 'data-is-bookmark-item', count=len(bookmarks))
+
+        for bookmark in bookmarks:
+            self.assertInHTML(
+                '<a href="{0}" target="_blank" rel="noopener">{1}</a>'.format(bookmark.url, bookmark.resolved_title),
+                html
+            )
+
+    def assertInvisibleBookmarks(self, response, bookmarks: [Bookmark]):
+        html = response.content.decode()
+
+        for bookmark in bookmarks:
+            self.assertInHTML(
+                '<a href="{0}" target="_blank" rel="noopener">{1}</a>'.format(bookmark.url, bookmark.resolved_title),
+                html,
+                count=0
+            )
+
+    def assertVisibleTags(self, response, tags: [Tag]):
+        self.assertContains(response, 'data-is-tag-item', count=len(tags))
+
+        for tag in tags:
+            self.assertContains(response, tag.name)
+
+    def assertInvisibleTags(self, response, tags: [Tag]):
+        for tag in tags:
+            self.assertNotContains(response, tag.name)
+
+    def test_should_list_unarchived_and_user_owned_bookmarks(self):
+        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
+        visible_bookmarks = [
+            self.setup_bookmark(),
+            self.setup_bookmark(),
+            self.setup_bookmark()
+        ]
+        invisible_bookmarks = [
+            self.setup_bookmark(is_archived=True),
+            self.setup_bookmark(user=other_user),
+        ]
+
+        response = self.client.get(reverse('bookmarks:index'))
+
+        self.assertContains(response, '<ul class="bookmark-list">')  # Should render list
+        self.assertVisibleBookmarks(response, visible_bookmarks)
+        self.assertInvisibleBookmarks(response, invisible_bookmarks)
+
+    def test_should_list_bookmarks_matching_query(self):
+        visible_bookmarks = [
+            self.setup_bookmark(title='searchvalue'),
+            self.setup_bookmark(title='searchvalue'),
+            self.setup_bookmark(title='searchvalue')
+        ]
+        invisible_bookmarks = [
+            self.setup_bookmark(),
+            self.setup_bookmark(),
+            self.setup_bookmark()
+        ]
+
+        response = self.client.get(reverse('bookmarks:index') + '?q=searchvalue')
+
+        self.assertContains(response, '<ul class="bookmark-list">')  # Should render list
+        self.assertVisibleBookmarks(response, visible_bookmarks)
+        self.assertInvisibleBookmarks(response, invisible_bookmarks)
+
+    def test_should_list_tags_for_unarchived_and_user_owned_bookmarks(self):
+        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
+        visible_tags = [
+            self.setup_tag(),
+            self.setup_tag(),
+            self.setup_tag(),
+        ]
+        invisible_tags = [
+            self.setup_tag(),  # unused tag
+            self.setup_tag(),  # used in archived bookmark
+            self.setup_tag(user=other_user),  # belongs to other user
+        ]
+
+        # Assign tags to some bookmarks with duplicates
+        self.setup_bookmark(tags=[visible_tags[0]])
+        self.setup_bookmark(tags=[visible_tags[0]])
+        self.setup_bookmark(tags=[visible_tags[1]])
+        self.setup_bookmark(tags=[visible_tags[1]])
+        self.setup_bookmark(tags=[visible_tags[2]])
+        self.setup_bookmark(tags=[visible_tags[2]])
+
+        self.setup_bookmark(tags=[invisible_tags[1]], is_archived=True)
+        self.setup_bookmark(tags=[invisible_tags[2]], user=other_user)
+
+        response = self.client.get(reverse('bookmarks:index'))
+
+        self.assertVisibleTags(response, visible_tags)
+        self.assertInvisibleTags(response, invisible_tags)
+
+    def test_should_list_tags_for_bookmarks_matching_query(self):
+        visible_tags = [
+            self.setup_tag(),
+            self.setup_tag(),
+            self.setup_tag(),
+        ]
+        invisible_tags = [
+            self.setup_tag(),
+            self.setup_tag(),
+            self.setup_tag(),
+        ]
+
+        self.setup_bookmark(tags=[visible_tags[0]], title='searchvalue'),
+        self.setup_bookmark(tags=[visible_tags[1]], title='searchvalue')
+        self.setup_bookmark(tags=[visible_tags[2]], title='searchvalue')
+        self.setup_bookmark(tags=[invisible_tags[0]])
+        self.setup_bookmark(tags=[invisible_tags[1]])
+        self.setup_bookmark(tags=[invisible_tags[2]])
+
+        response = self.client.get(reverse('bookmarks:index') + '?q=searchvalue')
+
+        self.assertVisibleTags(response, visible_tags)
+        self.assertInvisibleTags(response, invisible_tags)
--- a/bookmarks/tests/test_bookmark_new_view.py
+++ b/bookmarks/tests/test_bookmark_new_view.py
@@ -0,0 +1,81 @@
+from django.test import TestCase
+from django.urls import reverse
+
+from bookmarks.models import Bookmark
+from bookmarks.tests.helpers import BookmarkFactoryMixin
+
+
+class BookmarkNewViewTestCase(TestCase, BookmarkFactoryMixin):
+
+    def setUp(self) -> None:
+        user = self.get_or_create_test_user()
+        self.client.force_login(user)
+
+    def create_form_data(self, overrides=None):
+        if overrides is None:
+            overrides = {}
+        form_data = {
+            'url': 'http://example.com',
+            'tag_string': 'tag1 tag2',
+            'title': 'test title',
+            'description': 'test description',
+            'auto_close': '',
+        }
+        return {**form_data, **overrides}
+
+    def test_should_create_new_bookmark(self):
+        form_data = self.create_form_data()
+
+        self.client.post(reverse('bookmarks:new'), form_data)
+
+        self.assertEqual(Bookmark.objects.count(), 1)
+
+        bookmark = Bookmark.objects.first()
+        self.assertEqual(bookmark.owner, self.user)
+        self.assertEqual(bookmark.url, form_data['url'])
+        self.assertEqual(bookmark.title, form_data['title'])
+        self.assertEqual(bookmark.description, form_data['description'])
+        self.assertEqual(bookmark.tags.count(), 2)
+        self.assertEqual(bookmark.tags.all()[0].name, 'tag1')
+        self.assertEqual(bookmark.tags.all()[1].name, 'tag2')
+
+    def test_should_prefill_url_from_url_parameter(self):
+        response = self.client.get(reverse('bookmarks:new') + '?url=http://example.com')
+        html = response.content.decode()
+
+        self.assertInHTML(
+            '<input type="text" name="url" value="http://example.com" '
+            'placeholder=" " autofocus class="form-input" required '
+            'id="id_url">',
+            html)
+
+    def test_should_enable_auto_close_when_specified_in_url_parameter(self):
+        response = self.client.get(
+            reverse('bookmarks:new') + '?auto_close')
+        html = response.content.decode()
+
+        self.assertInHTML(
+            '<input type="hidden" name="auto_close" value="true" '
+            'id="id_auto_close">',
+            html)
+
+    def test_should_not_enable_auto_close_when_not_specified_in_url_parameter(
+            self):
+        response = self.client.get(reverse('bookmarks:new'))
+        html = response.content.decode()
+
+        self.assertInHTML('<input type="hidden" name="auto_close" id="id_auto_close">',html)
+
+    def test_should_redirect_to_index_view(self):
+        form_data = self.create_form_data()
+
+        response = self.client.post(reverse('bookmarks:new'), form_data)
+
+        self.assertRedirects(response, reverse('bookmarks:index'))
+
+    def test_auto_close_should_redirect_to_close_view(self):
+        form_data = self.create_form_data({'auto_close': 'true'})
+
+        response = self.client.post(reverse('bookmarks:new'), form_data)
+
+        self.assertRedirects(response, reverse('bookmarks:close'))
--- a/bookmarks/tests/test_bookmark_remove_view.py
+++ b/bookmarks/tests/test_bookmark_remove_view.py
@@ -0,0 +1,35 @@
+from django.test import TestCase
+from django.urls import reverse
+
+from bookmarks.models import Bookmark
+from bookmarks.tests.helpers import BookmarkFactoryMixin
+
+
+class BookmarkRemoveViewTestCase(TestCase, BookmarkFactoryMixin):
+
+    def setUp(self) -> None:
+        user = self.get_or_create_test_user()
+        self.client.force_login(user)
+
+    def test_should_delete_bookmark(self):
+        bookmark = self.setup_bookmark()
+
+        self.client.get(reverse('bookmarks:remove', args=[bookmark.id]))
+
+        self.assertEqual(Bookmark.objects.count(), 0)
+
+    def test_should_redirect_to_index(self):
+        bookmark = self.setup_bookmark()
+
+        response = self.client.get(reverse('bookmarks:remove', args=[bookmark.id]))
+
+        self.assertRedirects(response, reverse('bookmarks:index'))
+
+    def test_should_redirect_to_return_url_when_specified(self):
+        bookmark = self.setup_bookmark()
+
+        response = self.client.get(
+            reverse('bookmarks:remove', args=[bookmark.id]) + '?return_url=' + reverse('bookmarks:close')
+        )
+
+        self.assertRedirects(response, reverse('bookmarks:close'))
--- a/bookmarks/tests/test_bookmark_unarchive_view.py
+++ b/bookmarks/tests/test_bookmark_unarchive_view.py
@@ -0,0 +1,35 @@
+from django.test import TestCase
+from django.urls import reverse
+
+from bookmarks.tests.helpers import BookmarkFactoryMixin
+
+
+class BookmarkUnarchiveViewTestCase(TestCase, BookmarkFactoryMixin):
+
+    def setUp(self) -> None:
+        user = self.get_or_create_test_user()
+        self.client.force_login(user)
+
+    def test_should_unarchive_bookmark(self):
+        bookmark = self.setup_bookmark(is_archived=True)
+
+        self.client.get(reverse('bookmarks:unarchive', args=[bookmark.id]))
+        bookmark.refresh_from_db()
+
+        self.assertFalse(bookmark.is_archived)
+
+    def test_should_redirect_to_archive(self):
+        bookmark = self.setup_bookmark()
+
+        response = self.client.get(reverse('bookmarks:unarchive', args=[bookmark.id]))
+
+        self.assertRedirects(response, reverse('bookmarks:archived'))
+
+    def test_should_redirect_to_return_url_when_specified(self):
+        bookmark = self.setup_bookmark()
+
+        response = self.client.get(
+            reverse('bookmarks:unarchive', args=[bookmark.id]) + '?return_url=' + reverse('bookmarks:close')
+        )
+
+        self.assertRedirects(response, reverse('bookmarks:close'))
--- a/bookmarks/tests/test_bookmark_validation.py
+++ b/bookmarks/tests/test_bookmark_validation.py
@@ -34,6 +34,27 @@ class BookmarkValidationTestCase(TestCase):
    def setUp(self) -> None:
        self.user = User.objects.create_user('testuser', 'test@example.com', 'password123')

+    def test_bookmark_model_should_not_allow_missing_url(self):
+        bookmark = Bookmark(
+            date_added=datetime.datetime.now(),
+            date_modified=datetime.datetime.now(),
+            owner=self.user
+        )
+
+        with self.assertRaises(ValidationError):
+            bookmark.full_clean()
+
+    def test_bookmark_model_should_not_allow_empty_url(self):
+        bookmark = Bookmark(
+            url='',
+            date_added=datetime.datetime.now(),
+            date_modified=datetime.datetime.now(),
+            owner=self.user
+        )
+
+        with self.assertRaises(ValidationError):
+            bookmark.full_clean()
+
    @override_settings(LD_DISABLE_URL_VALIDATION=False)
    def test_bookmark_model_should_validate_url_if_not_disabled_in_settings(self):
        self._run_bookmark_model_url_validity_checks(ENABLED_URL_VALIDATION_TEST_CASES)
--- a/bookmarks/tests/test_bookmarks_api.py
+++ b/bookmarks/tests/test_bookmarks_api.py
@@ -0,0 +1,138 @@
+from collections import OrderedDict
+
+from django.contrib.auth.models import User
+from django.urls import reverse
+from rest_framework import status
+from rest_framework.authtoken.models import Token
+
+from bookmarks.models import Bookmark
+from bookmarks.tests.helpers import LinkdingApiTestCase, BookmarkFactoryMixin
+
+
+class BookmarksApiTestCase(LinkdingApiTestCase, BookmarkFactoryMixin):
+
+    def setUp(self) -> None:
+        self.api_token = Token.objects.get_or_create(user=self.get_or_create_test_user())[0]
+        self.client.credentials(HTTP_AUTHORIZATION='Token ' + self.api_token.key)
+        self.tag1 = self.setup_tag()
+        self.tag2 = self.setup_tag()
+        self.bookmark1 = self.setup_bookmark(tags=[self.tag1, self.tag2])
+        self.bookmark2 = self.setup_bookmark()
+        self.bookmark3 = self.setup_bookmark(tags=[self.tag2])
+        self.archived_bookmark1 = self.setup_bookmark(is_archived=True, tags=[self.tag1, self.tag2])
+        self.archived_bookmark2 = self.setup_bookmark(is_archived=True)
+
+    def assertBookmarkListEqual(self, data_list, bookmarks):
+        expectations = []
+        for bookmark in bookmarks:
+            tag_names = [tag.name for tag in bookmark.tags.all()]
+            tag_names.sort(key=str.lower)
+            expectation = OrderedDict()
+            expectation['id'] = bookmark.id
+            expectation['url'] = bookmark.url
+            expectation['title'] = bookmark.title
+            expectation['description'] = bookmark.description
+            expectation['website_title'] = bookmark.website_title
+            expectation['website_description'] = bookmark.website_description
+            expectation['tag_names'] = tag_names
+            expectation['date_added'] = bookmark.date_added.isoformat().replace('+00:00', 'Z')
+            expectation['date_modified'] = bookmark.date_modified.isoformat().replace('+00:00', 'Z')
+            expectations.append(expectation)
+
+        for data in data_list:
+            data['tag_names'].sort(key=str.lower)
+
+        self.assertCountEqual(data_list, expectations)
+
+    def test_create_bookmark(self):
+        data = {
+            'url': 'https://example.com/',
+            'title': 'Test title',
+            'description': 'Test description',
+            'tag_names': ['tag1', 'tag2']
+        }
+        self.post(reverse('bookmarks:bookmark-list'), data, status.HTTP_201_CREATED)
+        bookmark = Bookmark.objects.get(url=data['url'])
+        self.assertEqual(bookmark.url, data['url'])
+        self.assertEqual(bookmark.title, data['title'])
+        self.assertEqual(bookmark.description, data['description'])
+        self.assertEqual(bookmark.tags.count(), 2)
+        self.assertEqual(bookmark.tags.filter(name=data['tag_names'][0]).count(), 1)
+        self.assertEqual(bookmark.tags.filter(name=data['tag_names'][1]).count(), 1)
+
+    def test_create_bookmark_minimal_payload(self):
+        data = {'url': 'https://example.com/'}
+        self.post(reverse('bookmarks:bookmark-list'), data, status.HTTP_201_CREATED)
+
+    def test_list_bookmarks(self):
+        response = self.get(reverse('bookmarks:bookmark-list'), expected_status_code=status.HTTP_200_OK)
+        self.assertBookmarkListEqual(response.data['results'], [self.bookmark1, self.bookmark2, self.bookmark3])
+
+    def test_list_bookmarks_should_filter_by_query(self):
+        response = self.get(reverse('bookmarks:bookmark-list') + '?q=#' + self.tag1.name, expected_status_code=status.HTTP_200_OK)
+        self.assertBookmarkListEqual(response.data['results'], [self.bookmark1])
+
+    def test_list_archived_bookmarks_does_not_return_unarchived_bookmarks(self):
+        response = self.get(reverse('bookmarks:bookmark-archived'), expected_status_code=status.HTTP_200_OK)
+        self.assertBookmarkListEqual(response.data['results'], [self.archived_bookmark1, self.archived_bookmark2])
+
+    def test_list_archived_bookmarks_should_filter_by_query(self):
+        response = self.get(reverse('bookmarks:bookmark-archived') + '?q=#' + self.tag1.name, expected_status_code=status.HTTP_200_OK)
+        self.assertBookmarkListEqual(response.data['results'], [self.archived_bookmark1])
+
+    def test_get_bookmark(self):
+        url = reverse('bookmarks:bookmark-detail', args=[self.bookmark1.id])
+        response = self.get(url, expected_status_code=status.HTTP_200_OK)
+        self.assertBookmarkListEqual([response.data], [self.bookmark1])
+
+    def test_update_bookmark(self):
+        data = {'url': 'https://example.com/'}
+        url = reverse('bookmarks:bookmark-detail', args=[self.bookmark1.id])
+        self.put(url, data, expected_status_code=status.HTTP_200_OK)
+        updated_bookmark = Bookmark.objects.get(id=self.bookmark1.id)
+        self.assertEqual(updated_bookmark.url, data['url'])
+
+    def test_delete_bookmark(self):
+        url = reverse('bookmarks:bookmark-detail', args=[self.bookmark1.id])
+        self.delete(url, expected_status_code=status.HTTP_204_NO_CONTENT)
+        self.assertEqual(len(Bookmark.objects.filter(id=self.bookmark1.id)), 0)
+
+    def test_archive(self):
+        url = reverse('bookmarks:bookmark-archive', args=[self.bookmark1.id])
+        self.post(url, expected_status_code=status.HTTP_204_NO_CONTENT)
+        bookmark = Bookmark.objects.get(id=self.bookmark1.id)
+        self.assertTrue(bookmark.is_archived)
+
+    def test_unarchive(self):
+        url = reverse('bookmarks:bookmark-unarchive', args=[self.archived_bookmark1.id])
+        self.post(url, expected_status_code=status.HTTP_204_NO_CONTENT)
+        bookmark = Bookmark.objects.get(id=self.archived_bookmark1.id)
+        self.assertFalse(bookmark.is_archived)
+
+    def test_can_only_access_own_bookmarks(self):
+        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
+        inaccessible_bookmark = self.setup_bookmark(user=other_user)
+        self.setup_bookmark(user=other_user, is_archived=True)
+
+        url = reverse('bookmarks:bookmark-list')
+        response = self.get(url, expected_status_code=status.HTTP_200_OK)
+        self.assertEqual(len(response.data['results']), 3)
+
+        url = reverse('bookmarks:bookmark-archived')
+        response = self.get(url, expected_status_code=status.HTTP_200_OK)
+        self.assertEqual(len(response.data['results']), 2)
+
+        url = reverse('bookmarks:bookmark-detail', args=[inaccessible_bookmark.id])
+        self.get(url, expected_status_code=status.HTTP_404_NOT_FOUND)
+
+        url = reverse('bookmarks:bookmark-detail', args=[inaccessible_bookmark.id])
+        self.put(url, {url: 'https://example.com/'}, expected_status_code=status.HTTP_404_NOT_FOUND)
+
+        url = reverse('bookmarks:bookmark-detail', args=[inaccessible_bookmark.id])
+        self.delete(url, expected_status_code=status.HTTP_404_NOT_FOUND)
+
+        url = reverse('bookmarks:bookmark-archive', args=[inaccessible_bookmark.id])
+        self.post(url, expected_status_code=status.HTTP_404_NOT_FOUND)
+
+        url = reverse('bookmarks:bookmark-unarchive', args=[inaccessible_bookmark.id])
+        self.post(url, expected_status_code=status.HTTP_404_NOT_FOUND)
--- a/bookmarks/tests/test_bookmarks_list_tag.py
+++ b/bookmarks/tests/test_bookmarks_list_tag.py
@@ -0,0 +1,51 @@
+from dateutil.relativedelta import relativedelta
+from django.core.paginator import Paginator
+from django.template import Template, RequestContext
+from django.test import TestCase, RequestFactory
+from django.utils import timezone, formats
+
+from bookmarks.models import UserProfile
+from bookmarks.tests.helpers import BookmarkFactoryMixin
+
+
+class BookmarkListTagTest(TestCase, BookmarkFactoryMixin):
+
+    def render_template(self, bookmarks) -> str:
+        rf = RequestFactory()
+        request = rf.get('/test')
+        request.user = self.get_or_create_test_user()
+        paginator = Paginator(bookmarks, 10)
+        page = paginator.page(1)
+
+        context = RequestContext(request, {'bookmarks': page, 'return_url': '/test'})
+        template_to_render = Template(
+            '{% load bookmarks %}'
+            '{% bookmark_list bookmarks return_url %}'
+        )
+        return template_to_render.render(context)
+
+    def setup_date_format_test(self, date_display_setting):
+        bookmark = self.setup_bookmark()
+        bookmark.date_added = timezone.now() - relativedelta(days=8)
+        bookmark.save()
+        user = self.get_or_create_test_user()
+        user.profile.bookmark_date_display = date_display_setting
+        user.profile.save()
+        return bookmark
+
+    def test_should_respect_absolute_date_setting(self):
+        bookmark = self.setup_date_format_test(UserProfile.BOOKMARK_DATE_DISPLAY_ABSOLUTE)
+        html = self.render_template([bookmark])
+        formatted_date = formats.date_format(bookmark.date_added, 'SHORT_DATE_FORMAT')
+
+        self.assertInHTML(f'''
+        <span class="text-gray text-sm">{formatted_date}</span>
+        ''', html)
+
+    def test_should_respect_relative_date_setting(self):
+        bookmark = self.setup_date_format_test(UserProfile.BOOKMARK_DATE_DISPLAY_RELATIVE)
+        html = self.render_template([bookmark])
+
+        self.assertInHTML('''
+        <span class="text-gray text-sm">1 week ago</span>
+        ''', html)
--- a/bookmarks/tests/test_bookmarks_service.py
+++ b/bookmarks/tests/test_bookmarks_service.py
@@ -2,18 +2,20 @@ 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
+from bookmarks.models import Bookmark, Tag
+from bookmarks.services.bookmarks import archive_bookmark, archive_bookmarks, unarchive_bookmark, unarchive_bookmarks, \
+    delete_bookmarks, tag_bookmarks, untag_bookmarks
+from bookmarks.tests.helpers import BookmarkFactoryMixin

 User = get_user_model()


-class BookmarkServiceTestCase(TestCase):
+class BookmarkServiceTestCase(TestCase, BookmarkFactoryMixin):

    def setUp(self) -> None:
        self.user = User.objects.create_user('testuser', 'test@example.com', 'password123')

-    def test_archive(self):
+    def test_archive_bookmark(self):
        bookmark = Bookmark(
            url='https://example.com',
            date_added=timezone.now(),
@@ -30,7 +32,7 @@ class BookmarkServiceTestCase(TestCase):

        self.assertTrue(updated_bookmark.is_archived)

-    def test_unarchive(self):
+    def test_unarchive_bookmark(self):
        bookmark = Bookmark(
            url='https://example.com',
            date_added=timezone.now(),
@@ -45,3 +47,297 @@ class BookmarkServiceTestCase(TestCase):
        updated_bookmark = Bookmark.objects.get(id=bookmark.id)

        self.assertFalse(updated_bookmark.is_archived)
+
+    def test_archive_bookmarks(self):
+        bookmark1 = self.setup_bookmark()
+        bookmark2 = self.setup_bookmark()
+        bookmark3 = self.setup_bookmark()
+
+        archive_bookmarks([bookmark1.id, bookmark2.id, bookmark3.id], self.get_or_create_test_user())
+
+        self.assertTrue(Bookmark.objects.get(id=bookmark1.id).is_archived)
+        self.assertTrue(Bookmark.objects.get(id=bookmark2.id).is_archived)
+        self.assertTrue(Bookmark.objects.get(id=bookmark3.id).is_archived)
+
+    def test_archive_bookmarks_should_only_archive_specified_bookmarks(self):
+        bookmark1 = self.setup_bookmark()
+        bookmark2 = self.setup_bookmark()
+        bookmark3 = self.setup_bookmark()
+
+        archive_bookmarks([bookmark1.id, bookmark3.id], self.get_or_create_test_user())
+
+        self.assertTrue(Bookmark.objects.get(id=bookmark1.id).is_archived)
+        self.assertFalse(Bookmark.objects.get(id=bookmark2.id).is_archived)
+        self.assertTrue(Bookmark.objects.get(id=bookmark3.id).is_archived)
+
+    def test_archive_bookmarks_should_only_archive_user_owned_bookmarks(self):
+        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
+        bookmark1 = self.setup_bookmark()
+        bookmark2 = self.setup_bookmark()
+        inaccessible_bookmark = self.setup_bookmark(user=other_user)
+
+        archive_bookmarks([bookmark1.id, bookmark2.id, inaccessible_bookmark.id], self.get_or_create_test_user())
+
+        self.assertTrue(Bookmark.objects.get(id=bookmark1.id).is_archived)
+        self.assertTrue(Bookmark.objects.get(id=bookmark2.id).is_archived)
+        self.assertFalse(Bookmark.objects.get(id=inaccessible_bookmark.id).is_archived)
+
+    def test_archive_bookmarks_should_accept_mix_of_int_and_string_ids(self):
+        bookmark1 = self.setup_bookmark()
+        bookmark2 = self.setup_bookmark()
+        bookmark3 = self.setup_bookmark()
+
+        archive_bookmarks([str(bookmark1.id), bookmark2.id, str(bookmark3.id)], self.get_or_create_test_user())
+
+        self.assertTrue(Bookmark.objects.get(id=bookmark1.id).is_archived)
+        self.assertTrue(Bookmark.objects.get(id=bookmark2.id).is_archived)
+        self.assertTrue(Bookmark.objects.get(id=bookmark3.id).is_archived)
+
+    def test_unarchive_bookmarks(self):
+        bookmark1 = self.setup_bookmark(is_archived=True)
+        bookmark2 = self.setup_bookmark(is_archived=True)
+        bookmark3 = self.setup_bookmark(is_archived=True)
+
+        unarchive_bookmarks([bookmark1.id, bookmark2.id, bookmark3.id], self.get_or_create_test_user())
+
+        self.assertFalse(Bookmark.objects.get(id=bookmark1.id).is_archived)
+        self.assertFalse(Bookmark.objects.get(id=bookmark2.id).is_archived)
+        self.assertFalse(Bookmark.objects.get(id=bookmark3.id).is_archived)
+
+    def test_unarchive_bookmarks_should_only_unarchive_specified_bookmarks(self):
+        bookmark1 = self.setup_bookmark(is_archived=True)
+        bookmark2 = self.setup_bookmark(is_archived=True)
+        bookmark3 = self.setup_bookmark(is_archived=True)
+
+        unarchive_bookmarks([bookmark1.id, bookmark3.id], self.get_or_create_test_user())
+
+        self.assertFalse(Bookmark.objects.get(id=bookmark1.id).is_archived)
+        self.assertTrue(Bookmark.objects.get(id=bookmark2.id).is_archived)
+        self.assertFalse(Bookmark.objects.get(id=bookmark3.id).is_archived)
+
+    def test_unarchive_bookmarks_should_only_unarchive_user_owned_bookmarks(self):
+        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
+        bookmark1 = self.setup_bookmark(is_archived=True)
+        bookmark2 = self.setup_bookmark(is_archived=True)
+        inaccessible_bookmark = self.setup_bookmark(is_archived=True, user=other_user)
+
+        unarchive_bookmarks([bookmark1.id, bookmark2.id, inaccessible_bookmark.id], self.get_or_create_test_user())
+
+        self.assertFalse(Bookmark.objects.get(id=bookmark1.id).is_archived)
+        self.assertFalse(Bookmark.objects.get(id=bookmark2.id).is_archived)
+        self.assertTrue(Bookmark.objects.get(id=inaccessible_bookmark.id).is_archived)
+
+    def test_unarchive_bookmarks_should_accept_mix_of_int_and_string_ids(self):
+        bookmark1 = self.setup_bookmark(is_archived=True)
+        bookmark2 = self.setup_bookmark(is_archived=True)
+        bookmark3 = self.setup_bookmark(is_archived=True)
+
+        unarchive_bookmarks([str(bookmark1.id), bookmark2.id, str(bookmark3.id)], self.get_or_create_test_user())
+
+        self.assertFalse(Bookmark.objects.get(id=bookmark1.id).is_archived)
+        self.assertFalse(Bookmark.objects.get(id=bookmark2.id).is_archived)
+        self.assertFalse(Bookmark.objects.get(id=bookmark3.id).is_archived)
+
+    def test_delete_bookmarks(self):
+        bookmark1 = self.setup_bookmark()
+        bookmark2 = self.setup_bookmark()
+        bookmark3 = self.setup_bookmark()
+
+        delete_bookmarks([bookmark1.id, bookmark2.id, bookmark3.id], self.get_or_create_test_user())
+
+        self.assertIsNone(Bookmark.objects.filter(id=bookmark1.id).first())
+        self.assertIsNone(Bookmark.objects.filter(id=bookmark2.id).first())
+        self.assertIsNone(Bookmark.objects.filter(id=bookmark3.id).first())
+
+    def test_delete_bookmarks_should_only_delete_specified_bookmarks(self):
+        bookmark1 = self.setup_bookmark()
+        bookmark2 = self.setup_bookmark()
+        bookmark3 = self.setup_bookmark()
+
+        delete_bookmarks([bookmark1.id, bookmark3.id], self.get_or_create_test_user())
+
+        self.assertIsNone(Bookmark.objects.filter(id=bookmark1.id).first())
+        self.assertIsNotNone(Bookmark.objects.filter(id=bookmark2.id).first())
+        self.assertIsNone(Bookmark.objects.filter(id=bookmark3.id).first())
+
+    def test_delete_bookmarks_should_only_delete_user_owned_bookmarks(self):
+        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
+        bookmark1 = self.setup_bookmark()
+        bookmark2 = self.setup_bookmark()
+        inaccessible_bookmark = self.setup_bookmark(user=other_user)
+
+        delete_bookmarks([bookmark1.id, bookmark2.id, inaccessible_bookmark.id], self.get_or_create_test_user())
+
+        self.assertIsNone(Bookmark.objects.filter(id=bookmark1.id).first())
+        self.assertIsNone(Bookmark.objects.filter(id=bookmark2.id).first())
+        self.assertIsNotNone(Bookmark.objects.filter(id=inaccessible_bookmark.id).first())
+
+    def test_delete_bookmarks_should_accept_mix_of_int_and_string_ids(self):
+        bookmark1 = self.setup_bookmark()
+        bookmark2 = self.setup_bookmark()
+        bookmark3 = self.setup_bookmark()
+
+        delete_bookmarks([bookmark1.id, bookmark2.id, bookmark3.id], self.get_or_create_test_user())
+
+        self.assertIsNone(Bookmark.objects.filter(id=bookmark1.id).first())
+        self.assertIsNone(Bookmark.objects.filter(id=bookmark2.id).first())
+        self.assertIsNone(Bookmark.objects.filter(id=bookmark3.id).first())
+
+    def test_tag_bookmarks(self):
+        bookmark1 = self.setup_bookmark()
+        bookmark2 = self.setup_bookmark()
+        bookmark3 = self.setup_bookmark()
+        tag1 = self.setup_tag()
+        tag2 = self.setup_tag()
+
+        tag_bookmarks([bookmark1.id, bookmark2.id, bookmark3.id], f'{tag1.name} {tag2.name}',
+                      self.get_or_create_test_user())
+
+        bookmark1.refresh_from_db()
+        bookmark2.refresh_from_db()
+        bookmark3.refresh_from_db()
+
+        self.assertCountEqual(bookmark1.tags.all(), [tag1, tag2])
+        self.assertCountEqual(bookmark2.tags.all(), [tag1, tag2])
+        self.assertCountEqual(bookmark3.tags.all(), [tag1, tag2])
+
+    def test_tag_bookmarks_should_create_tags(self):
+        bookmark1 = self.setup_bookmark()
+        bookmark2 = self.setup_bookmark()
+        bookmark3 = self.setup_bookmark()
+
+        tag_bookmarks([bookmark1.id, bookmark2.id, bookmark3.id], 'tag1 tag2', self.get_or_create_test_user())
+
+        bookmark1.refresh_from_db()
+        bookmark2.refresh_from_db()
+        bookmark3.refresh_from_db()
+
+        self.assertEqual(2, Tag.objects.count())
+
+        tag1 = Tag.objects.filter(name='tag1').first()
+        tag2 = Tag.objects.filter(name='tag2').first()
+
+        self.assertIsNotNone(tag1)
+        self.assertIsNotNone(tag2)
+
+        self.assertCountEqual(bookmark1.tags.all(), [tag1, tag2])
+        self.assertCountEqual(bookmark2.tags.all(), [tag1, tag2])
+        self.assertCountEqual(bookmark3.tags.all(), [tag1, tag2])
+
+    def test_tag_bookmarks_should_only_tag_specified_bookmarks(self):
+        bookmark1 = self.setup_bookmark()
+        bookmark2 = self.setup_bookmark()
+        bookmark3 = self.setup_bookmark()
+        tag1 = self.setup_tag()
+        tag2 = self.setup_tag()
+
+        tag_bookmarks([bookmark1.id, bookmark3.id], f'{tag1.name} {tag2.name}', self.get_or_create_test_user())
+
+        bookmark1.refresh_from_db()
+        bookmark2.refresh_from_db()
+        bookmark3.refresh_from_db()
+
+        self.assertCountEqual(bookmark1.tags.all(), [tag1, tag2])
+        self.assertCountEqual(bookmark2.tags.all(), [])
+        self.assertCountEqual(bookmark3.tags.all(), [tag1, tag2])
+
+    def test_tag_bookmarks_should_only_tag_user_owned_bookmarks(self):
+        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
+        bookmark1 = self.setup_bookmark()
+        bookmark2 = self.setup_bookmark()
+        inaccessible_bookmark = self.setup_bookmark(user=other_user)
+        tag1 = self.setup_tag()
+        tag2 = self.setup_tag()
+
+        tag_bookmarks([bookmark1.id, bookmark2.id, inaccessible_bookmark.id], f'{tag1.name} {tag2.name}',
+                      self.get_or_create_test_user())
+
+        bookmark1.refresh_from_db()
+        bookmark2.refresh_from_db()
+        inaccessible_bookmark.refresh_from_db()
+
+        self.assertCountEqual(bookmark1.tags.all(), [tag1, tag2])
+        self.assertCountEqual(bookmark2.tags.all(), [tag1, tag2])
+        self.assertCountEqual(inaccessible_bookmark.tags.all(), [])
+
+    def test_tag_bookmarks_should_accept_mix_of_int_and_string_ids(self):
+        bookmark1 = self.setup_bookmark()
+        bookmark2 = self.setup_bookmark()
+        bookmark3 = self.setup_bookmark()
+        tag1 = self.setup_tag()
+        tag2 = self.setup_tag()
+
+        tag_bookmarks([str(bookmark1.id), bookmark2.id, str(bookmark3.id)], f'{tag1.name} {tag2.name}',
+                      self.get_or_create_test_user())
+
+        self.assertCountEqual(bookmark1.tags.all(), [tag1, tag2])
+        self.assertCountEqual(bookmark2.tags.all(), [tag1, tag2])
+        self.assertCountEqual(bookmark3.tags.all(), [tag1, tag2])
+
+    def test_untag_bookmarks(self):
+        tag1 = self.setup_tag()
+        tag2 = self.setup_tag()
+        bookmark1 = self.setup_bookmark(tags=[tag1, tag2])
+        bookmark2 = self.setup_bookmark(tags=[tag1, tag2])
+        bookmark3 = self.setup_bookmark(tags=[tag1, tag2])
+
+        untag_bookmarks([bookmark1.id, bookmark2.id, bookmark3.id], f'{tag1.name} {tag2.name}',
+                        self.get_or_create_test_user())
+
+        bookmark1.refresh_from_db()
+        bookmark2.refresh_from_db()
+        bookmark3.refresh_from_db()
+
+        self.assertCountEqual(bookmark1.tags.all(), [])
+        self.assertCountEqual(bookmark2.tags.all(), [])
+        self.assertCountEqual(bookmark3.tags.all(), [])
+
+    def test_untag_bookmarks_should_only_tag_specified_bookmarks(self):
+        tag1 = self.setup_tag()
+        tag2 = self.setup_tag()
+        bookmark1 = self.setup_bookmark(tags=[tag1, tag2])
+        bookmark2 = self.setup_bookmark(tags=[tag1, tag2])
+        bookmark3 = self.setup_bookmark(tags=[tag1, tag2])
+
+        untag_bookmarks([bookmark1.id, bookmark3.id], f'{tag1.name} {tag2.name}', self.get_or_create_test_user())
+
+        bookmark1.refresh_from_db()
+        bookmark2.refresh_from_db()
+        bookmark3.refresh_from_db()
+
+        self.assertCountEqual(bookmark1.tags.all(), [])
+        self.assertCountEqual(bookmark2.tags.all(), [tag1, tag2])
+        self.assertCountEqual(bookmark3.tags.all(), [])
+
+    def test_untag_bookmarks_should_only_tag_user_owned_bookmarks(self):
+        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
+        tag1 = self.setup_tag()
+        tag2 = self.setup_tag()
+        bookmark1 = self.setup_bookmark(tags=[tag1, tag2])
+        bookmark2 = self.setup_bookmark(tags=[tag1, tag2])
+        inaccessible_bookmark = self.setup_bookmark(user=other_user, tags=[tag1, tag2])
+
+        untag_bookmarks([bookmark1.id, bookmark2.id, inaccessible_bookmark.id], f'{tag1.name} {tag2.name}',
+                        self.get_or_create_test_user())
+
+        bookmark1.refresh_from_db()
+        bookmark2.refresh_from_db()
+        inaccessible_bookmark.refresh_from_db()
+
+        self.assertCountEqual(bookmark1.tags.all(), [])
+        self.assertCountEqual(bookmark2.tags.all(), [])
+        self.assertCountEqual(inaccessible_bookmark.tags.all(), [tag1, tag2])
+
+    def test_untag_bookmarks_should_accept_mix_of_int_and_string_ids(self):
+        tag1 = self.setup_tag()
+        tag2 = self.setup_tag()
+        bookmark1 = self.setup_bookmark(tags=[tag1, tag2])
+        bookmark2 = self.setup_bookmark(tags=[tag1, tag2])
+        bookmark3 = self.setup_bookmark(tags=[tag1, tag2])
+
+        untag_bookmarks([str(bookmark1.id), bookmark2.id, str(bookmark3.id)], f'{tag1.name} {tag2.name}',
+                        self.get_or_create_test_user())
+
+        self.assertCountEqual(bookmark1.tags.all(), [])
+        self.assertCountEqual(bookmark2.tags.all(), [])
+        self.assertCountEqual(bookmark3.tags.all(), [])
--- a/bookmarks/tests/test_importer.py
+++ b/bookmarks/tests/test_importer.py
@@ -0,0 +1,33 @@
+from django.test import TestCase
+
+from bookmarks.services.importer import import_netscape_html
+from bookmarks.tests.helpers import BookmarkFactoryMixin, disable_logging
+
+
+class ImporterTestCase(TestCase, BookmarkFactoryMixin):
+
+    def create_import_html(self, bookmark_tags_string: str):
+        return f'''
+<!DOCTYPE NETSCAPE-Bookmark-file-1>
+<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8">
+<TITLE>Bookmarks</TITLE>
+<H1>Bookmarks</H1>
+<DL><p>
+{bookmark_tags_string}
+</DL><p>
+        '''
+
+    @disable_logging
+    def test_validate_empty_or_missing_bookmark_url(self):
+        test_html = self.create_import_html(f'''
+            <!-- Empty URL -->
+            <DT><A HREF="" ADD_DATE="1616337559" PRIVATE="0" TOREAD="0" TAGS="tag3">Empty URL</A>
+            <DD>Empty URL
+            <!-- Missing URL -->
+            <DT><A ADD_DATE="1616337559" PRIVATE="0" TOREAD="0" TAGS="tag3">Missing URL</A>
+            <DD>Missing URL
+        ''')
+
+        import_result = import_netscape_html(test_html, self.get_or_create_test_user())
+
+        self.assertEqual(import_result.success, 0)
--- a/bookmarks/tests/test_pagination_tag.py
+++ b/bookmarks/tests/test_pagination_tag.py
@@ -1,6 +1,6 @@
 from django.core.paginator import Paginator
-from django.test import SimpleTestCase, RequestFactory
 from django.template import Template, RequestContext
+from django.test import SimpleTestCase, RequestFactory


 class PaginationTagTest(SimpleTestCase):
--- a/bookmarks/tests/test_queries.py
+++ b/bookmarks/tests/test_queries.py
@@ -1,38 +1,222 @@
+import operator
+
 from django.contrib.auth import get_user_model
+from django.db.models import QuerySet
 from django.test import TestCase
-from django.utils import timezone
-from django.utils.crypto import get_random_string
-from bookmarks.models import Bookmark, Tag
+
 from bookmarks import queries
+from bookmarks.models import Bookmark
+from bookmarks.tests.helpers import BookmarkFactoryMixin, random_sentence
+from bookmarks.utils import unique

 User = get_user_model()


-class QueriesTestCase(TestCase):
+class QueriesTestCase(TestCase, BookmarkFactoryMixin):

-    def setUp(self) -> None:
-        self.user = User.objects.create_user('testuser', 'test@example.com', 'password123')
+    def setup_bookmark_search_data(self) -> None:
+        tag1 = self.setup_tag(name='tag1')
+        tag2 = self.setup_tag(name='tag2')
+        self.setup_tag(name='unused_tag1')

-    def setup_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
+        self.other_bookmarks = [
+            self.setup_bookmark(),
+            self.setup_bookmark(),
+            self.setup_bookmark(),
+        ]
+        self.term1_bookmarks = [
+            self.setup_bookmark(url='http://example.com/term1'),
+            self.setup_bookmark(title=random_sentence(including_word='term1')),
+            self.setup_bookmark(description=random_sentence(including_word='term1')),
+            self.setup_bookmark(website_title=random_sentence(including_word='term1')),
+            self.setup_bookmark(website_description=random_sentence(including_word='term1')),
+        ]
+        self.term1_term2_bookmarks = [
+            self.setup_bookmark(url='http://example.com/term1/term2'),
+            self.setup_bookmark(title=random_sentence(including_word='term1'),
+                                description=random_sentence(including_word='term2')),
+            self.setup_bookmark(description=random_sentence(including_word='term1'),
+                                title=random_sentence(including_word='term2')),
+            self.setup_bookmark(website_title=random_sentence(including_word='term1'),
+                                title=random_sentence(including_word='term2')),
+            self.setup_bookmark(website_description=random_sentence(including_word='term1'),
+                                title=random_sentence(including_word='term2')),
+        ]
+        self.tag1_bookmarks = [
+            self.setup_bookmark(tags=[tag1]),
+            self.setup_bookmark(title=random_sentence(), tags=[tag1]),
+            self.setup_bookmark(description=random_sentence(), tags=[tag1]),
+            self.setup_bookmark(website_title=random_sentence(), tags=[tag1]),
+            self.setup_bookmark(website_description=random_sentence(), tags=[tag1]),
+        ]
+        self.term1_tag1_bookmarks = [
+            self.setup_bookmark(url='http://example.com/term1', tags=[tag1]),
+            self.setup_bookmark(title=random_sentence(including_word='term1'), tags=[tag1]),
+            self.setup_bookmark(description=random_sentence(including_word='term1'), tags=[tag1]),
+            self.setup_bookmark(website_title=random_sentence(including_word='term1'), tags=[tag1]),
+            self.setup_bookmark(website_description=random_sentence(including_word='term1'), tags=[tag1]),
+        ]
+        self.tag2_bookmarks = [
+            self.setup_bookmark(tags=[tag2]),
+        ]
+        self.tag1_tag2_bookmarks = [
+            self.setup_bookmark(tags=[tag1, tag2]),
+        ]

-    def setup_tag(self):
-        name = get_random_string(length=32)
-        tag = Tag(name=name, date_added=timezone.now(), owner=self.user)
-        tag.save()
-        return tag
+    def setup_tag_search_data(self):
+        tag1 = self.setup_tag(name='tag1')
+        tag2 = self.setup_tag(name='tag2')
+        self.setup_tag(name='unused_tag1')
+
+        self.other_bookmarks = [
+            self.setup_bookmark(tags=[self.setup_tag()]),
+            self.setup_bookmark(tags=[self.setup_tag()]),
+            self.setup_bookmark(tags=[self.setup_tag()]),
+        ]
+        self.term1_bookmarks = [
+            self.setup_bookmark(url='http://example.com/term1', tags=[self.setup_tag()]),
+            self.setup_bookmark(title=random_sentence(including_word='term1'), tags=[self.setup_tag()]),
+            self.setup_bookmark(description=random_sentence(including_word='term1'), tags=[self.setup_tag()]),
+            self.setup_bookmark(website_title=random_sentence(including_word='term1'), tags=[self.setup_tag()]),
+            self.setup_bookmark(website_description=random_sentence(including_word='term1'), tags=[self.setup_tag()]),
+        ]
+        self.term1_term2_bookmarks = [
+            self.setup_bookmark(url='http://example.com/term1/term2', tags=[self.setup_tag()]),
+            self.setup_bookmark(title=random_sentence(including_word='term1'),
+                                description=random_sentence(including_word='term2'),
+                                tags=[self.setup_tag()]),
+            self.setup_bookmark(description=random_sentence(including_word='term1'),
+                                title=random_sentence(including_word='term2'),
+                                tags=[self.setup_tag()]),
+            self.setup_bookmark(website_title=random_sentence(including_word='term1'),
+                                title=random_sentence(including_word='term2'),
+                                tags=[self.setup_tag()]),
+            self.setup_bookmark(website_description=random_sentence(including_word='term1'),
+                                title=random_sentence(including_word='term2'),
+                                tags=[self.setup_tag()]),
+        ]
+        self.tag1_bookmarks = [
+            self.setup_bookmark(tags=[tag1, self.setup_tag()]),
+            self.setup_bookmark(title=random_sentence(), tags=[tag1, self.setup_tag()]),
+            self.setup_bookmark(description=random_sentence(), tags=[tag1, self.setup_tag()]),
+            self.setup_bookmark(website_title=random_sentence(), tags=[tag1, self.setup_tag()]),
+            self.setup_bookmark(website_description=random_sentence(), tags=[tag1, self.setup_tag()]),
+        ]
+        self.term1_tag1_bookmarks = [
+            self.setup_bookmark(url='http://example.com/term1', tags=[tag1, self.setup_tag()]),
+            self.setup_bookmark(title=random_sentence(including_word='term1'), tags=[tag1, self.setup_tag()]),
+            self.setup_bookmark(description=random_sentence(including_word='term1'), tags=[tag1, self.setup_tag()]),
+            self.setup_bookmark(website_title=random_sentence(including_word='term1'), tags=[tag1, self.setup_tag()]),
+            self.setup_bookmark(website_description=random_sentence(including_word='term1'),
+                                tags=[tag1, self.setup_tag()]),
+        ]
+        self.tag2_bookmarks = [
+            self.setup_bookmark(tags=[tag2, self.setup_tag()]),
+        ]
+        self.tag1_tag2_bookmarks = [
+            self.setup_bookmark(tags=[tag1, tag2, self.setup_tag()]),
+        ]
+
+    def get_tags_from_bookmarks(self, bookmarks: [Bookmark]):
+        all_tags = []
+        for bookmark in bookmarks:
+            all_tags = all_tags + list(bookmark.tags.all())
+        return all_tags
+
+    def assertQueryResult(self, query: QuerySet, item_lists: [[any]]):
+        expected_items = []
+        for item_list in item_lists:
+            expected_items = expected_items + item_list
+
+        expected_items = unique(expected_items, operator.attrgetter('id'))
+
+        self.assertCountEqual(list(query), expected_items)
+
+    def test_query_bookmarks_should_return_all_for_empty_query(self):
+        self.setup_bookmark_search_data()
+
+        query = queries.query_bookmarks(self.get_or_create_test_user(), '')
+        self.assertQueryResult(query, [
+            self.other_bookmarks,
+            self.term1_bookmarks,
+            self.term1_term2_bookmarks,
+            self.tag1_bookmarks,
+            self.term1_tag1_bookmarks,
+            self.tag2_bookmarks,
+            self.tag1_tag2_bookmarks
+        ])
+
+    def test_query_bookmarks_should_search_single_term(self):
+        self.setup_bookmark_search_data()
+
+        query = queries.query_bookmarks(self.get_or_create_test_user(), 'term1')
+        self.assertQueryResult(query, [
+            self.term1_bookmarks,
+            self.term1_term2_bookmarks,
+            self.term1_tag1_bookmarks
+        ])
+
+    def test_query_bookmarks_should_search_multiple_terms(self):
+        self.setup_bookmark_search_data()
+
+        query = queries.query_bookmarks(self.get_or_create_test_user(), 'term2 term1')
+
+        self.assertQueryResult(query, [self.term1_term2_bookmarks])
+
+    def test_query_bookmarks_should_search_single_tag(self):
+        self.setup_bookmark_search_data()
+
+        query = queries.query_bookmarks(self.get_or_create_test_user(), '#tag1')
+
+        self.assertQueryResult(query, [self.tag1_bookmarks, self.tag1_tag2_bookmarks, self.term1_tag1_bookmarks])
+
+    def test_query_bookmarks_should_search_multiple_tags(self):
+        self.setup_bookmark_search_data()
+
+        query = queries.query_bookmarks(self.get_or_create_test_user(), '#tag1 #tag2')
+
+        self.assertQueryResult(query, [self.tag1_tag2_bookmarks])
+
+    def test_query_bookmarks_should_search_multiple_tags_ignoring_casing(self):
+        self.setup_bookmark_search_data()
+
+        query = queries.query_bookmarks(self.get_or_create_test_user(), '#Tag1 #TAG2')
+
+        self.assertQueryResult(query, [self.tag1_tag2_bookmarks])
+
+    def test_query_bookmarks_should_search_terms_and_tags_combined(self):
+        self.setup_bookmark_search_data()
+
+        query = queries.query_bookmarks(self.get_or_create_test_user(), 'term1 #tag1')
+
+        self.assertQueryResult(query, [self.term1_tag1_bookmarks])
+
+    def test_query_bookmarks_should_return_no_matches(self):
+        self.setup_bookmark_search_data()
+
+        query = queries.query_bookmarks(self.get_or_create_test_user(), 'term3')
+        self.assertQueryResult(query, [])
+
+        query = queries.query_bookmarks(self.get_or_create_test_user(), 'term1 term3')
+        self.assertQueryResult(query, [])
+
+        query = queries.query_bookmarks(self.get_or_create_test_user(), 'term1 #tag2')
+        self.assertQueryResult(query, [])
+
+        query = queries.query_bookmarks(self.get_or_create_test_user(), '#tag3')
+        self.assertQueryResult(query, [])
+
+        # Unused tag
+        query = queries.query_bookmarks(self.get_or_create_test_user(), '#unused_tag1')
+        self.assertQueryResult(query, [])
+
+        # Unused tag combined with tag that is used
+        query = queries.query_bookmarks(self.get_or_create_test_user(), '#tag1 #unused_tag1')
+        self.assertQueryResult(query, [])
+
+        # Unused tag combined with term that is used
+        query = queries.query_bookmarks(self.get_or_create_test_user(), 'term1 #unused_tag1')
+        self.assertQueryResult(query, [])

    def test_query_bookmarks_should_not_return_archived_bookmarks(self):
        bookmark1 = self.setup_bookmark()
@@ -41,9 +225,9 @@ class QueriesTestCase(TestCase):
        self.setup_bookmark(is_archived=True)
        self.setup_bookmark(is_archived=True)

-        query = queries.query_bookmarks(self.user, '')
+        query = queries.query_bookmarks(self.get_or_create_test_user(), '')

-        self.assertCountEqual([bookmark1, bookmark2], list(query))
+        self.assertQueryResult(query, [[bookmark1, bookmark2]])

    def test_query_archived_bookmarks_should_not_return_unarchived_bookmarks(self):
        bookmark1 = self.setup_bookmark(is_archived=True)
@@ -52,9 +236,158 @@ class QueriesTestCase(TestCase):
        self.setup_bookmark()
        self.setup_bookmark()

+        query = queries.query_archived_bookmarks(self.get_or_create_test_user(), '')
+
+        self.assertQueryResult(query, [[bookmark1, bookmark2]])
+
+    def test_query_bookmarks_should_only_return_user_owned_bookmarks(self):
+        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
+        owned_bookmarks = [
+            self.setup_bookmark(),
+            self.setup_bookmark(),
+            self.setup_bookmark(),
+        ]
+        self.setup_bookmark(user=other_user)
+        self.setup_bookmark(user=other_user)
+        self.setup_bookmark(user=other_user)
+
+        query = queries.query_bookmarks(self.user, '')
+
+        self.assertQueryResult(query, [owned_bookmarks])
+
+    def test_query_archived_bookmarks_should_only_return_user_owned_bookmarks(self):
+        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
+        owned_bookmarks = [
+            self.setup_bookmark(is_archived=True),
+            self.setup_bookmark(is_archived=True),
+            self.setup_bookmark(is_archived=True),
+        ]
+        self.setup_bookmark(is_archived=True, user=other_user)
+        self.setup_bookmark(is_archived=True, user=other_user)
+        self.setup_bookmark(is_archived=True, user=other_user)
+
        query = queries.query_archived_bookmarks(self.user, '')

-        self.assertCountEqual([bookmark1, bookmark2], list(query))
+        self.assertQueryResult(query, [owned_bookmarks])
+
+    def test_query_bookmarks_should_use_tag_projection(self):
+        self.setup_bookmark_search_data()
+
+        # Test projection on bookmarks with tags
+        query = queries.query_bookmarks(self.user, '#tag1 #tag2')
+
+        for bookmark in query:
+            self.assertEqual(bookmark.tag_count, 2)
+            self.assertEqual(bookmark.tag_string, 'tag1,tag2')
+            self.assertTrue(bookmark.tag_projection)
+
+        # Test projection on bookmarks without tags
+        query = queries.query_bookmarks(self.user, 'term2')
+
+        for bookmark in query:
+            self.assertEqual(bookmark.tag_count, 0)
+            self.assertEqual(bookmark.tag_string, None)
+            self.assertTrue(bookmark.tag_projection)
+
+    def test_query_bookmark_tags_should_return_all_tags_for_empty_query(self):
+        self.setup_tag_search_data()
+
+        query = queries.query_bookmark_tags(self.user, '')
+
+        self.assertQueryResult(query, [
+            self.get_tags_from_bookmarks(self.other_bookmarks),
+            self.get_tags_from_bookmarks(self.term1_bookmarks),
+            self.get_tags_from_bookmarks(self.term1_term2_bookmarks),
+            self.get_tags_from_bookmarks(self.tag1_bookmarks),
+            self.get_tags_from_bookmarks(self.term1_tag1_bookmarks),
+            self.get_tags_from_bookmarks(self.tag2_bookmarks),
+            self.get_tags_from_bookmarks(self.tag1_tag2_bookmarks),
+        ])
+
+    def test_query_bookmark_tags_should_search_single_term(self):
+        self.setup_tag_search_data()
+
+        query = queries.query_bookmark_tags(self.user, 'term1')
+
+        self.assertQueryResult(query, [
+            self.get_tags_from_bookmarks(self.term1_bookmarks),
+            self.get_tags_from_bookmarks(self.term1_term2_bookmarks),
+            self.get_tags_from_bookmarks(self.term1_tag1_bookmarks),
+        ])
+
+    def test_query_bookmark_tags_should_search_multiple_terms(self):
+        self.setup_tag_search_data()
+
+        query = queries.query_bookmark_tags(self.user, 'term2 term1')
+
+        self.assertQueryResult(query, [
+            self.get_tags_from_bookmarks(self.term1_term2_bookmarks),
+        ])
+
+    def test_query_bookmark_tags_should_search_single_tag(self):
+        self.setup_tag_search_data()
+
+        query = queries.query_bookmark_tags(self.user, '#tag1')
+
+        self.assertQueryResult(query, [
+            self.get_tags_from_bookmarks(self.tag1_bookmarks),
+            self.get_tags_from_bookmarks(self.term1_tag1_bookmarks),
+            self.get_tags_from_bookmarks(self.tag1_tag2_bookmarks),
+        ])
+
+    def test_query_bookmark_tags_should_search_multiple_tags(self):
+        self.setup_tag_search_data()
+
+        query = queries.query_bookmark_tags(self.user, '#tag1 #tag2')
+
+        self.assertQueryResult(query, [
+            self.get_tags_from_bookmarks(self.tag1_tag2_bookmarks),
+        ])
+
+    def test_query_bookmark_tags_should_search_multiple_tags_ignoring_casing(self):
+        self.setup_tag_search_data()
+
+        query = queries.query_bookmark_tags(self.user, '#Tag1 #TAG2')
+
+        self.assertQueryResult(query, [
+            self.get_tags_from_bookmarks(self.tag1_tag2_bookmarks),
+        ])
+
+    def test_query_bookmark_tags_should_search_term_and_tag_combined(self):
+        self.setup_tag_search_data()
+
+        query = queries.query_bookmark_tags(self.user, 'term1 #tag1')
+
+        self.assertQueryResult(query, [
+            self.get_tags_from_bookmarks(self.term1_tag1_bookmarks),
+        ])
+
+    def test_query_bookmark_tags_should_return_no_matches(self):
+        self.setup_tag_search_data()
+
+        query = queries.query_bookmark_tags(self.get_or_create_test_user(), 'term3')
+        self.assertQueryResult(query, [])
+
+        query = queries.query_bookmark_tags(self.get_or_create_test_user(), 'term1 term3')
+        self.assertQueryResult(query, [])
+
+        query = queries.query_bookmark_tags(self.get_or_create_test_user(), 'term1 #tag2')
+        self.assertQueryResult(query, [])
+
+        query = queries.query_bookmark_tags(self.get_or_create_test_user(), '#tag3')
+        self.assertQueryResult(query, [])
+
+        # Unused tag
+        query = queries.query_bookmark_tags(self.get_or_create_test_user(), '#unused_tag1')
+        self.assertQueryResult(query, [])
+
+        # Unused tag combined with tag that is used
+        query = queries.query_bookmark_tags(self.get_or_create_test_user(), '#tag1 #unused_tag1')
+        self.assertQueryResult(query, [])
+
+        # Unused tag combined with term that is used
+        query = queries.query_bookmark_tags(self.get_or_create_test_user(), 'term1 #unused_tag1')
+        self.assertQueryResult(query, [])

    def test_query_bookmark_tags_should_return_tags_for_unarchived_bookmarks_only(self):
        tag1 = self.setup_tag()
@@ -63,9 +396,9 @@ class QueriesTestCase(TestCase):
        self.setup_bookmark()
        self.setup_bookmark(is_archived=True, tags=[tag2])

-        query = queries.query_bookmark_tags(self.user, '')
+        query = queries.query_bookmark_tags(self.get_or_create_test_user(), '')

-        self.assertCountEqual([tag1], list(query))
+        self.assertQueryResult(query, [[tag1]])

    def test_query_bookmark_tags_should_return_distinct_tags(self):
        tag = self.setup_tag()
@@ -73,9 +406,9 @@ class QueriesTestCase(TestCase):
        self.setup_bookmark(tags=[tag])
        self.setup_bookmark(tags=[tag])

-        query = queries.query_bookmark_tags(self.user, '')
+        query = queries.query_bookmark_tags(self.get_or_create_test_user(), '')

-        self.assertCountEqual([tag], list(query))
+        self.assertQueryResult(query, [[tag]])

    def test_query_archived_bookmark_tags_should_return_tags_for_archived_bookmarks_only(self):
        tag1 = self.setup_tag()
@@ -84,9 +417,9 @@ class QueriesTestCase(TestCase):
        self.setup_bookmark()
        self.setup_bookmark(is_archived=True, tags=[tag2])

-        query = queries.query_archived_bookmark_tags(self.user, '')
+        query = queries.query_archived_bookmark_tags(self.get_or_create_test_user(), '')

-        self.assertCountEqual([tag2], list(query))
+        self.assertQueryResult(query, [[tag2]])

    def test_query_archived_bookmark_tags_should_return_distinct_tags(self):
        tag = self.setup_tag()
@@ -94,6 +427,36 @@ class QueriesTestCase(TestCase):
        self.setup_bookmark(is_archived=True, tags=[tag])
        self.setup_bookmark(is_archived=True, tags=[tag])

+        query = queries.query_archived_bookmark_tags(self.get_or_create_test_user(), '')
+
+        self.assertQueryResult(query, [[tag]])
+
+    def test_query_bookmark_tags_should_only_return_user_owned_tags(self):
+        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
+        owned_bookmarks = [
+            self.setup_bookmark(tags=[self.setup_tag()]),
+            self.setup_bookmark(tags=[self.setup_tag()]),
+            self.setup_bookmark(tags=[self.setup_tag()]),
+        ]
+        self.setup_bookmark(user=other_user, tags=[self.setup_tag(user=other_user)])
+        self.setup_bookmark(user=other_user, tags=[self.setup_tag(user=other_user)])
+        self.setup_bookmark(user=other_user, tags=[self.setup_tag(user=other_user)])
+
+        query = queries.query_bookmark_tags(self.user, '')
+
+        self.assertQueryResult(query, [self.get_tags_from_bookmarks(owned_bookmarks)])
+
+    def test_query_archived_bookmark_tags_should_only_return_user_owned_tags(self):
+        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
+        owned_bookmarks = [
+            self.setup_bookmark(is_archived=True, tags=[self.setup_tag()]),
+            self.setup_bookmark(is_archived=True, tags=[self.setup_tag()]),
+            self.setup_bookmark(is_archived=True, tags=[self.setup_tag()]),
+        ]
+        self.setup_bookmark(is_archived=True, user=other_user, tags=[self.setup_tag(user=other_user)])
+        self.setup_bookmark(is_archived=True, user=other_user, tags=[self.setup_tag(user=other_user)])
+        self.setup_bookmark(is_archived=True, user=other_user, tags=[self.setup_tag(user=other_user)])
+
        query = queries.query_archived_bookmark_tags(self.user, '')

-        self.assertCountEqual([tag], list(query))
+        self.assertQueryResult(query, [self.get_tags_from_bookmarks(owned_bookmarks)])
--- a/bookmarks/tests/test_settings_api_view.py
+++ b/bookmarks/tests/test_settings_api_view.py
@@ -0,0 +1,40 @@
+from django.test import TestCase
+from django.urls import reverse
+from rest_framework.authtoken.models import Token
+
+from bookmarks.tests.helpers import BookmarkFactoryMixin
+
+
+class SettingsApiViewTestCase(TestCase, BookmarkFactoryMixin):
+
+    def setUp(self) -> None:
+        user = self.get_or_create_test_user()
+        self.client.force_login(user)
+
+    def test_should_render_successfully(self):
+        response = self.client.get(reverse('bookmarks:settings.api'))
+
+        self.assertEqual(response.status_code, 200)
+
+    def test_should_check_authentication(self):
+        self.client.logout()
+        response = self.client.get(reverse('bookmarks:settings.api'), follow=True)
+
+        self.assertRedirects(response, reverse('login') + '?next=' + reverse('bookmarks:settings.api'))
+
+    def test_should_generate_api_token_if_not_exists(self):
+        self.assertEqual(Token.objects.count(), 0)
+
+        self.client.get(reverse('bookmarks:settings.api'))
+
+        self.assertEqual(Token.objects.count(), 1)
+        token = Token.objects.first()
+        self.assertEqual(token.user, self.user)
+
+    def test_should_not_generate_api_token_if_exists(self):
+        Token.objects.get_or_create(user=self.user)
+        self.assertEqual(Token.objects.count(), 1)
+
+        self.client.get(reverse('bookmarks:settings.api'))
+
+        self.assertEqual(Token.objects.count(), 1)
--- a/bookmarks/tests/test_settings_export_view.py
+++ b/bookmarks/tests/test_settings_export_view.py
@@ -0,0 +1,45 @@
+from unittest.mock import patch
+
+from django.test import TestCase
+from django.urls import reverse
+
+from bookmarks.tests.helpers import BookmarkFactoryMixin
+
+
+class SettingsExportViewTestCase(TestCase, BookmarkFactoryMixin):
+
+    def setUp(self) -> None:
+        user = self.get_or_create_test_user()
+        self.client.force_login(user)
+
+    def assertFormErrorHint(self, response, text: str):
+        self.assertContains(response, '<div class="has-error">')
+        self.assertContains(response, text)
+
+    def test_should_export_successfully(self):
+        self.setup_bookmark(tags=[self.setup_tag()])
+        self.setup_bookmark(tags=[self.setup_tag()])
+        self.setup_bookmark(tags=[self.setup_tag()])
+
+        response = self.client.get(
+            reverse('bookmarks:settings.export'),
+            follow=True
+        )
+
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response['content-type'], 'text/plain; charset=UTF-8')
+        self.assertEqual(response['Content-Disposition'], 'attachment; filename="bookmarks.html"')
+
+    def test_should_check_authentication(self):
+        self.client.logout()
+        response = self.client.get(reverse('bookmarks:settings.export'), follow=True)
+
+        self.assertRedirects(response, reverse('login') + '?next=' + reverse('bookmarks:settings.export'))
+
+    def test_should_show_hint_when_export_raises_error(self):
+        with patch('bookmarks.services.exporter.export_netscape_html') as mock_export_netscape_html:
+            mock_export_netscape_html.side_effect = Exception('Nope')
+            response = self.client.get(reverse('bookmarks:settings.export'), follow=True)
+
+            self.assertTemplateUsed(response, 'settings/general.html')
+            self.assertFormErrorHint(response, 'An error occurred during bookmark export.')
--- a/bookmarks/tests/test_settings_general_view.py
+++ b/bookmarks/tests/test_settings_general_view.py
@@ -0,0 +1,36 @@
+from django.test import TestCase
+from django.urls import reverse
+
+from bookmarks.tests.helpers import BookmarkFactoryMixin
+from bookmarks.models import UserProfile
+
+
+class SettingsGeneralViewTestCase(TestCase, BookmarkFactoryMixin):
+
+    def setUp(self) -> None:
+        user = self.get_or_create_test_user()
+        self.client.force_login(user)
+
+    def test_should_render_successfully(self):
+        response = self.client.get(reverse('bookmarks:settings.general'))
+
+        self.assertEqual(response.status_code, 200)
+
+    def test_should_check_authentication(self):
+        self.client.logout()
+        response = self.client.get(reverse('bookmarks:settings.general'), follow=True)
+
+        self.assertRedirects(response, reverse('login') + '?next=' + reverse('bookmarks:settings.general'))
+
+    def test_should_save_profile(self):
+        form_data = {
+            'theme': UserProfile.THEME_DARK,
+            'bookmark_date_display': UserProfile.BOOKMARK_DATE_DISPLAY_HIDDEN,
+        }
+        response = self.client.post(reverse('bookmarks:settings.general'), form_data)
+
+        self.user.profile.refresh_from_db()
+
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(self.user.profile.theme, form_data['theme'])
+        self.assertEqual(self.user.profile.bookmark_date_display, form_data['bookmark_date_display'])
--- a/bookmarks/tests/test_settings_import_view.py
+++ b/bookmarks/tests/test_settings_import_view.py
@@ -0,0 +1,79 @@
+from django.test import TestCase
+from django.urls import reverse
+
+from bookmarks.tests.helpers import BookmarkFactoryMixin, disable_logging
+
+
+class SettingsImportViewTestCase(TestCase, BookmarkFactoryMixin):
+
+    def setUp(self) -> None:
+        user = self.get_or_create_test_user()
+        self.client.force_login(user)
+
+    def assertFormSuccessHint(self, response, text: str):
+        self.assertContains(response, '<div class="has-success">')
+        self.assertContains(response, text)
+
+    def assertNoFormSuccessHint(self, response):
+        self.assertNotContains(response, '<div class="has-success">')
+
+    def assertFormErrorHint(self, response, text: str):
+        self.assertContains(response, '<div class="has-error">')
+        self.assertContains(response, text)
+
+    def assertNoFormErrorHint(self, response):
+        self.assertNotContains(response, '<div class="has-error">')
+
+    def test_should_import_successfully(self):
+        with open('bookmarks/tests/resources/simple_valid_import_file.html') as import_file:
+            response = self.client.post(
+                reverse('bookmarks:settings.import'),
+                {'import_file': import_file},
+                follow=True
+            )
+
+            self.assertRedirects(response, reverse('bookmarks:settings.general'))
+            self.assertFormSuccessHint(response, '3 bookmarks were successfully imported')
+            self.assertNoFormErrorHint(response)
+
+    def test_should_check_authentication(self):
+        self.client.logout()
+        response = self.client.get(reverse('bookmarks:settings.import'), follow=True)
+
+        self.assertRedirects(response, reverse('login') + '?next=' + reverse('bookmarks:settings.import'))
+
+    def test_should_show_hint_if_there_is_no_file(self):
+        response = self.client.post(
+            reverse('bookmarks:settings.import'),
+            follow=True
+        )
+
+        self.assertRedirects(response, reverse('bookmarks:settings.general'))
+        self.assertNoFormSuccessHint(response)
+        self.assertFormErrorHint(response, 'Please select a file to import.')
+
+    @disable_logging
+    def test_should_show_hint_if_import_raises_exception(self):
+        with open('bookmarks/tests/resources/invalid_import_file.png', 'rb') as import_file:
+            response = self.client.post(
+                reverse('bookmarks:settings.import'),
+                {'import_file': import_file},
+                follow=True
+            )
+
+            self.assertRedirects(response, reverse('bookmarks:settings.general'))
+            self.assertNoFormSuccessHint(response)
+            self.assertFormErrorHint(response, 'An error occurred during bookmark import.')
+
+    @disable_logging
+    def test_should_show_respective_hints_if_not_all_bookmarks_were_imported_successfully(self):
+        with open('bookmarks/tests/resources/simple_valid_import_file_with_one_invalid_bookmark.html') as import_file:
+            response = self.client.post(
+                reverse('bookmarks:settings.import'),
+                {'import_file': import_file},
+                follow=True
+            )
+
+            self.assertRedirects(response, reverse('bookmarks:settings.general'))
+            self.assertFormSuccessHint(response, '2 bookmarks were successfully imported')
+            self.assertFormErrorHint(response, '1 bookmarks could not be imported')
--- a/bookmarks/tests/test_settings_integrations_view.py
+++ b/bookmarks/tests/test_settings_integrations_view.py
@@ -0,0 +1,22 @@
+from django.test import TestCase
+from django.urls import reverse
+
+from bookmarks.tests.helpers import BookmarkFactoryMixin
+
+
+class SettingsIntegrationsViewTestCase(TestCase, BookmarkFactoryMixin):
+
+    def setUp(self) -> None:
+        user = self.get_or_create_test_user()
+        self.client.force_login(user)
+
+    def test_should_render_successfully(self):
+        response = self.client.get(reverse('bookmarks:settings.integrations'))
+
+        self.assertEqual(response.status_code, 200)
+
+    def test_should_check_authentication(self):
+        self.client.logout()
+        response = self.client.get(reverse('bookmarks:settings.integrations'), follow=True)
+
+        self.assertRedirects(response, reverse('login') + '?next=' + reverse('bookmarks:settings.integrations'))
--- a/bookmarks/tests/test_tags_service.py
+++ b/bookmarks/tests/test_tags_service.py
@@ -1,4 +1,5 @@
 import datetime
+
 from django.contrib.auth import get_user_model
 from django.test import TestCase
 from django.utils import timezone
--- a/bookmarks/tests/test_user_profile_model.py
+++ b/bookmarks/tests/test_user_profile_model.py
@@ -0,0 +1,12 @@
+from django.contrib.auth.models import User
+from django.test import TestCase
+
+from bookmarks.models import UserProfile
+
+
+class UserProfileTestCase(TestCase):
+
+    def test_create_user_should_init_profile(self):
+        user = User.objects.create_user('testuser', 'test@example.com', 'password123')
+        profile = UserProfile.objects.all().filter(user_id=user.id).first()
+        self.assertIsNotNone(profile)
--- a/bookmarks/tests/test_utils.py
+++ b/bookmarks/tests/test_utils.py
@@ -0,0 +1,108 @@
+from unittest.mock import patch
+
+from dateutil.relativedelta import relativedelta
+from django.test import TestCase
+from django.utils import timezone
+
+from bookmarks.utils import humanize_absolute_date, humanize_relative_date, parse_timestamp
+
+
+class UtilsTestCase(TestCase):
+
+    def test_humanize_absolute_date(self):
+        test_cases = [
+            (timezone.datetime(2021, 1, 1), timezone.datetime(2023, 1, 1), '01/01/2021'),
+            (timezone.datetime(2021, 1, 1), timezone.datetime(2021, 2, 1), '01/01/2021'),
+            (timezone.datetime(2021, 1, 1), timezone.datetime(2021, 1, 8), '01/01/2021'),
+            (timezone.datetime(2021, 1, 1), timezone.datetime(2021, 1, 7), 'Friday'),
+            (timezone.datetime(2021, 1, 1), timezone.datetime(2021, 1, 7, 23, 59), 'Friday'),
+            (timezone.datetime(2021, 1, 1), timezone.datetime(2021, 1, 3), 'Friday'),
+            (timezone.datetime(2021, 1, 1), timezone.datetime(2021, 1, 2), 'Yesterday'),
+            (timezone.datetime(2021, 1, 1), timezone.datetime(2021, 1, 2, 23, 59), 'Yesterday'),
+            (timezone.datetime(2021, 1, 1), timezone.datetime(2021, 1, 1), 'Today'),
+        ]
+
+        for test_case in test_cases:
+            result = humanize_absolute_date(test_case[0], test_case[1])
+            self.assertEqual(test_case[2], result)
+
+    def test_humanize_absolute_date_should_use_current_date_as_default(self):
+        with patch.object(timezone, 'now', return_value=timezone.datetime(2021, 1, 1)):
+            self.assertEqual(humanize_absolute_date(timezone.datetime(2021, 1, 1)), 'Today')
+
+        # Regression: Test that subsequent calls use current date instead of cached date (#107)
+        with patch.object(timezone, 'now', return_value=timezone.datetime(2021, 1, 13)):
+            self.assertEqual(humanize_absolute_date(timezone.datetime(2021, 1, 13)), 'Today')
+
+    def test_humanize_relative_date(self):
+        test_cases = [
+            (timezone.datetime(2021, 1, 1), timezone.datetime(2022, 1, 1), '1 year ago'),
+            (timezone.datetime(2021, 1, 1), timezone.datetime(2022, 12, 31), '1 year ago'),
+            (timezone.datetime(2021, 1, 1), timezone.datetime(2023, 1, 1), '2 years ago'),
+            (timezone.datetime(2021, 1, 1), timezone.datetime(2023, 12, 31), '2 years ago'),
+            (timezone.datetime(2021, 1, 1), timezone.datetime(2021, 12, 31), '11 months ago'),
+            (timezone.datetime(2021, 1, 1), timezone.datetime(2021, 2, 1), '1 month ago'),
+            (timezone.datetime(2021, 1, 1), timezone.datetime(2021, 1, 31), '4 weeks ago'),
+            (timezone.datetime(2021, 1, 1), timezone.datetime(2021, 1, 14), '1 week ago'),
+            (timezone.datetime(2021, 1, 1), timezone.datetime(2021, 1, 8), '1 week ago'),
+            (timezone.datetime(2021, 1, 1), timezone.datetime(2021, 1, 7), 'Friday'),
+            (timezone.datetime(2021, 1, 1), timezone.datetime(2021, 1, 7, 23, 59), 'Friday'),
+            (timezone.datetime(2021, 1, 1), timezone.datetime(2021, 1, 3), 'Friday'),
+            (timezone.datetime(2021, 1, 1), timezone.datetime(2021, 1, 2), 'Yesterday'),
+            (timezone.datetime(2021, 1, 1), timezone.datetime(2021, 1, 2, 23, 59), 'Yesterday'),
+            (timezone.datetime(2021, 1, 1), timezone.datetime(2021, 1, 1), 'Today'),
+        ]
+
+        for test_case in test_cases:
+            result = humanize_relative_date(test_case[0], test_case[1])
+            self.assertEqual(test_case[2], result)
+
+    def test_humanize_relative_date_should_use_current_date_as_default(self):
+        with patch.object(timezone, 'now', return_value=timezone.datetime(2021, 1, 1)):
+            self.assertEqual(humanize_relative_date(timezone.datetime(2021, 1, 1)), 'Today')
+
+        # Regression: Test that subsequent calls use current date instead of cached date (#107)
+        with patch.object(timezone, 'now', return_value=timezone.datetime(2021, 1, 13)):
+            self.assertEqual(humanize_relative_date(timezone.datetime(2021, 1, 13)), 'Today')
+
+    def verify_timestamp(self, date, factor=1):
+        timestamp_string = str(int(date.timestamp() * factor))
+        parsed_date = parse_timestamp(timestamp_string)
+        self.assertEqual(date, parsed_date)
+
+    def test_parse_timestamp_fails_for_invalid_timestamps(self):
+        with self.assertRaises(ValueError):
+            parse_timestamp('invalid')
+
+    def test_parse_timestamp_parses_millisecond_timestamps(self):
+        now = timezone.now().replace(microsecond=0)
+        fifty_years_ago = now - relativedelta(year=50)
+        fifty_years_from_now = now + relativedelta(year=50)
+
+        self.verify_timestamp(now)
+        self.verify_timestamp(fifty_years_ago)
+        self.verify_timestamp(fifty_years_from_now)
+
+    def test_parse_timestamp_parses_microsecond_timestamps(self):
+        now = timezone.now().replace(microsecond=0)
+        fifty_years_ago = now - relativedelta(year=50)
+        fifty_years_from_now = now + relativedelta(year=50)
+
+        self.verify_timestamp(now, 1000)
+        self.verify_timestamp(fifty_years_ago, 1000)
+        self.verify_timestamp(fifty_years_from_now, 1000)
+
+    def test_parse_timestamp_parses_nanosecond_timestamps(self):
+        now = timezone.now().replace(microsecond=0)
+        fifty_years_ago = now - relativedelta(year=50)
+        fifty_years_from_now = now + relativedelta(year=50)
+
+        self.verify_timestamp(now, 1000000)
+        self.verify_timestamp(fifty_years_ago, 1000000)
+        self.verify_timestamp(fifty_years_from_now, 1000000)
+
+    def test_parse_timestamp_fails_for_out_of_range_timestamp(self):
+        now = timezone.now().replace(microsecond=0)
+
+        with self.assertRaises(ValueError):
+            self.verify_timestamp(now, 1000000000)
--- a/bookmarks/urls.py
+++ b/bookmarks/urls.py
@@ -18,8 +18,12 @@ urlpatterns = [
    path('bookmarks/<int:bookmark_id>/remove', views.bookmarks.remove, name='remove'),
    path('bookmarks/<int:bookmark_id>/archive', views.bookmarks.archive, name='archive'),
    path('bookmarks/<int:bookmark_id>/unarchive', views.bookmarks.unarchive, name='unarchive'),
+    path('bookmarks/bulkedit', views.bookmarks.bulk_edit, name='bulk_edit'),
    # Settings
-    path('settings', views.settings.index, name='settings.index'),
+    path('settings', views.settings.general, name='settings.index'),
+    path('settings/general', views.settings.general, name='settings.general'),
+    path('settings/integrations', views.settings.integrations, name='settings.integrations'),
+    path('settings/api', views.settings.api, name='settings.api'),
    path('settings/import', views.settings.bookmark_import, name='settings.import'),
    path('settings/export', views.settings.bookmark_export, name='settings.export'),
    # API
--- a/bookmarks/utils.py
+++ b/bookmarks/utils.py
@@ -1,2 +1,97 @@
+from datetime import datetime
+from typing import Optional
+
+from dateutil.relativedelta import relativedelta
+from django.template.defaultfilters import pluralize
+from django.utils import timezone, formats
+
+
 def unique(elements, key):
    return list({key(element): element for element in elements}.values())
+
+
+weekday_names = {
+    1: 'Monday',
+    2: 'Tuesday',
+    3: 'Wednesday',
+    4: 'Thursday',
+    5: 'Friday',
+    6: 'Saturday',
+    7: 'Sunday',
+}
+
+
+def humanize_absolute_date(value: datetime, now: Optional[datetime] = None):
+    if not now:
+        now = timezone.now()
+    delta = relativedelta(now, value)
+    yesterday = now - relativedelta(days=1)
+
+    is_older_than_a_week = delta.years > 0 or delta.months > 0 or delta.weeks > 0
+
+    if is_older_than_a_week:
+        return formats.date_format(value, 'SHORT_DATE_FORMAT')
+    elif value.day == now.day:
+        return 'Today'
+    elif value.day == yesterday.day:
+        return 'Yesterday'
+    else:
+        return weekday_names[value.isoweekday()]
+
+
+def humanize_relative_date(value: datetime, now: Optional[datetime] = None):
+    if not now:
+        now = timezone.now()
+    delta = relativedelta(now, value)
+
+    if delta.years > 0:
+        return f'{delta.years} year{pluralize(delta.years)} ago'
+    elif delta.months > 0:
+        return f'{delta.months} month{pluralize(delta.months)} ago'
+    elif delta.weeks > 0:
+        return f'{delta.weeks} week{pluralize(delta.weeks)} ago'
+    else:
+        yesterday = now - relativedelta(days=1)
+        if value.day == now.day:
+            return 'Today'
+        elif value.day == yesterday.day:
+            return 'Yesterday'
+        else:
+            return weekday_names[value.isoweekday()]
+
+
+def parse_timestamp(value: str):
+    """
+    Parses a string timestamp into a datetime value
+    First tries to parse the timestamp as milliseconds.
+    If that fails with an error indicating that the timestamp exceeds the maximum,
+    it tries to parse the timestamp as microseconds, and then as nanoseconds
+    :param value:
+    :return:
+    """
+    try:
+        timestamp = int(value)
+    except ValueError:
+        raise ValueError(f'{value} is not a valid timestamp')
+
+    try:
+        return datetime.utcfromtimestamp(timestamp).astimezone()
+    except (OverflowError, ValueError, OSError):
+        pass
+
+    # Value exceeds the max. allowed timestamp
+    # Try parsing as microseconds
+    try:
+        return datetime.utcfromtimestamp(timestamp / 1000).astimezone()
+    except (OverflowError, ValueError, OSError):
+        pass
+
+    # Value exceeds the max. allowed timestamp
+    # Try parsing as nanoseconds
+    try:
+        return datetime.utcfromtimestamp(timestamp / 1000000).astimezone()
+    except (OverflowError, ValueError, OSError):
+        pass
+
+    # Timestamp is out of range
+    raise ValueError(f'{value} exceeds maximum value for a timestamp')
--- a/bookmarks/views/bookmarks.py
+++ b/bookmarks/views/bookmarks.py
@@ -8,7 +8,8 @@ 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, archive_bookmark, unarchive_bookmark
+from bookmarks.services.bookmarks import create_bookmark, update_bookmark, archive_bookmark, archive_bookmarks, \
+    unarchive_bookmark, unarchive_bookmarks, delete_bookmarks, tag_bookmarks, untag_bookmarks

 _default_page_size = 30

@@ -87,11 +88,9 @@ def new(request):
        if initial_auto_close:
            form.initial['auto_close'] = 'true'

-    all_tags = queries.get_user_tags(request.user)
    context = {
        'form': form,
        'auto_close': initial_auto_close,
-        'all_tags': all_tags,
        'return_url': reverse('bookmarks:index')
    }

@@ -116,12 +115,10 @@ def edit(request, bookmark_id: int):

    form.initial['tag_string'] = build_tag_string(bookmark.tag_names, ' ')
    form.initial['return_url'] = return_url
-    all_tags = queries.get_user_tags(request.user)

    context = {
        'form': form,
        'bookmark_id': bookmark_id,
-        'all_tags': all_tags,
        'return_url': return_url
    }

@@ -155,6 +152,29 @@ def unarchive(request, bookmark_id: int):
    return HttpResponseRedirect(return_url)


+@login_required
+def bulk_edit(request):
+    bookmark_ids = request.POST.getlist('bookmark_id')
+
+    # Determine action
+    if 'bulk_archive' in request.POST:
+        archive_bookmarks(bookmark_ids, request.user)
+    if 'bulk_unarchive' in request.POST:
+        unarchive_bookmarks(bookmark_ids, request.user)
+    if 'bulk_delete' in request.POST:
+        delete_bookmarks(bookmark_ids, request.user)
+    if 'bulk_tag' in request.POST:
+        tag_string = request.POST['bulk_tag_string']
+        tag_bookmarks(bookmark_ids, tag_string, request.user)
+    if 'bulk_untag' in request.POST:
+        tag_string = request.POST['bulk_tag_string']
+        untag_bookmarks(bookmark_ids, tag_string, request.user)
+
+    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 close(request):
    return render(request, 'bookmarks/close.html')
--- a/bookmarks/views/settings.py
+++ b/bookmarks/views/settings.py
@@ -7,23 +7,51 @@ from django.shortcuts import render
 from django.urls import reverse
 from rest_framework.authtoken.models import Token

+from bookmarks.models import UserProfileForm
 from bookmarks.queries import query_bookmarks
-from bookmarks.services.exporter import export_netscape_html
-from bookmarks.services.importer import import_netscape_html
+from bookmarks.services import exporter
+from bookmarks.services import importer

 logger = logging.getLogger(__name__)

+try:
+    with open("version.txt", "r") as f:
+        app_version = f.read().strip("\n")
+except Exception as exc: 
+    logging.exception(exc)
+    pass

@login_required
-def index(request):
+def general(request):
+    if request.method == 'POST':
+        form = UserProfileForm(request.POST, instance=request.user.profile)
+        if form.is_valid():
+            form.save()
+    else:
+        form = UserProfileForm(instance=request.user.profile)
+
    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', {
+    return render(request, 'settings/general.html', {
+        'form': form,
        'import_success_message': import_success_message,
        'import_errors_message': import_errors_message,
+        'app_version': app_version
+    })
+
+
+@login_required
+def integrations(request):
+    application_url = request.build_absolute_uri("/bookmarks/new")
+    return render(request, 'settings/integrations.html', {
        'application_url': application_url,
+    })
+
+
+@login_required
+def api(request):
+    api_token = Token.objects.get_or_create(user=request.user)[0]
+    return render(request, 'settings/api.html', {
        'api_token': api_token.key
    })

@@ -34,11 +62,11 @@ def bookmark_import(request):

    if import_file is None:
        messages.error(request, 'Please select a file to import.', 'bookmark_import_errors')
-        return HttpResponseRedirect(reverse('bookmarks:settings.index'))
+        return HttpResponseRedirect(reverse('bookmarks:settings.general'))

    try:
        content = import_file.read().decode()
-        result = import_netscape_html(content, request.user)
+        result = importer.import_netscape_html(content, request.user)
        success_msg = str(result.success) + ' bookmarks were successfully imported.'
        messages.success(request, success_msg, 'bookmark_import_success')
        if result.failed > 0:
@@ -49,7 +77,7 @@ def bookmark_import(request):
        messages.error(request, 'An error occurred during bookmark import.', 'bookmark_import_errors')
        pass

-    return HttpResponseRedirect(reverse('bookmarks:settings.index'))
+    return HttpResponseRedirect(reverse('bookmarks:settings.general'))


@login_required
@@ -57,7 +85,7 @@ def bookmark_export(request):
    # noinspection PyBroadException
    try:
        bookmarks = query_bookmarks(request.user, '')
-        file_content = export_netscape_html(bookmarks)
+        file_content = exporter.export_netscape_html(bookmarks)

        response = HttpResponse(content_type='text/plain; charset=UTF-8')
        response['Content-Disposition'] = 'attachment; filename="bookmarks.html"'
@@ -65,7 +93,7 @@ def bookmark_export(request):

        return response
    except:
-        return render(request, 'settings/index.html', {
+        return render(request, 'settings/general.html', {
            'export_error': 'An error occurred during bookmark export.'
        })

--- a/build-docker.sh
+++ b/build-docker.sh
@@ -2,7 +2,6 @@

 version=$(<version.txt)

-./build-static.sh
 docker buildx build --platform linux/amd64,linux/arm64,linux/arm/v7 \
  -t sissbruecker/linkding:latest \
  -t sissbruecker/linkding:$version \
--- a/coverage.sh
+++ b/coverage.sh
@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+
+coverage erase
+coverage run manage.py test
+coverage report --sort=cover
--- a/docs/API.md
+++ b/docs/API.md
--- a/docs/Admin.md
+++ b/docs/Admin.md
@@ -0,0 +1,65 @@
+# Administration
+
+This document describes how to make use of the admin app that comes as part of each linkding installation. This is the default Django admin app with some linkding specific customizations.
+
+The admin app provides several features that are not available in the linkding UI:
+- User management and user self-management
+- Bookmark and tag management, including bulk operations
+
+## Linkding administration page
+
+To open the Admin app, go the *Settings* view and click on the *Admin* tab. This should open a new window with the admin app.
+
+Alternatively you can open the URL directly by adding `/admin` to the URL of your linkding installation.
+
+## User management
+
+Go to the linkding administration page and select *Users*.
+Here you can add and delete users, and change the password of a user.
+
+Once you have added a user you can, if needed, give the user staff status, which means this user can also access the linkding administration page.
+
+This page also allows you to change your own password if necessary.
+
+## Bookmark management
+
+While the linkding UI itself now has a bulk edit feature for bookmarks you can also use the admin app to manage bookmarks or to do bulk operations. 
+
+In the main linkding administration page, choose *Bookmarks*.
+
+First select the bookmarks to operate on:
+
+- Specify a filter to determine which bookmarks to operate on:
+  - In the column *by username*, you can choose to filter for bookmarks for a specific user
+  - In the column *by is archived*, you can choose to filter for bookmarks that are either archived or not
+  - In the column *by tags*, you can choose to filter for specific tags
+  - In the search box you can also add a text filter (note that this doesn't use the same search syntax as the linkding UI itself)  
+
+Now a list of bookmarks which match your filter is displayed, each bookmark on a separate line.
+Each line starts with a checkbox.
+Either choose the individual bookmarks you want to do a bulk operation on, or choose the top checkbox to select all shown bookmarks.
+
+Open the "Action" select box to choose the desired bulk operation:
+
+- Delete
+- Archive
+- Unarchive
+
+Click the button next to the checkbox to execute the operation.
+
+## Tag management
+
+While linkding UI currently only allows to create or assign tags, you can use the admin app to manage your tags. This can be especially useful if you want to clean up your tag collection.
+
+In the main linkding administration page, choose *Tags*.
+
+Similar to bookmarks management described above you can now specify which tags to operate on by specifying a filter and then selecting the individual tags.
+
+Open the "Action" select box to choose the desired bulk operation:
+
+- Delete
+- Delete unused tags - this will only delete the selected tags that are currently not assigned to any bookmark
+
+Click the button next to the checkbox to execute the operation.
+
+Note that deleting a tag does not affect the bookmarks that are tagged with this tag, it only removes the tag from those bookmarks.
--- a/docs/Options.md
+++ b/docs/Options.md
--- a/docs/backup.md
+++ b/docs/backup.md
@@ -0,0 +1,52 @@
+# Backups
+
+This page describes some options on how to create backups.
+
+## What to backup
+
+Linkding stores all data in a SQLite database, so all you need to backup are the contents of that database.
+
+The location of the database file is `data/db.sqlite3` in the application folder. 
+If you are using Docker then the full path in the Docker container is `/etc/linkding/data/db.sqlite`. 
+As described in the installation docs, you should mount the `/etc/linkding/data` folder to a folder on your host system, from which you then can execute the backup.
+
+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 plain textfile with the contents of the SQLite database with the SQLite dump function
+
+Choose the method that fits you best.
+
+## Exporting from the UI
+
+The least technical option is to use the bookmark export in the UI.
+Go to the settings page and open the *Data* tab. 
+Then click on the *Download* button to download an HTML file containing all your bookmarks.
+You can backup this file on a drive, or an online file host.
+
+## Using the SQLite backup function
+
+Requires [SQLite](https://www.sqlite.org/index.html) to be installed on your host system.
+
+With this method you create a new SQLite database, which is a copy of your linkding database.
+This method uses the backup command in the [Command Line Shell For SQLite](https://sqlite.org/cli.html).
+```shell
+sqlite3 db.sqlite3 ".backup 'backup.sqlite3'"
+```
+After you have created the backup database `backup.sqlite` you have to move it to another system, for example with rsync.
+
+## Using the SQLite dump function
+
+Requires [SQLite](https://www.sqlite.org/index.html) to be installed on your host system.
+
+With this method you create a plain text file with the SQL statements to recreate the SQLite database.
+
+```shell
+sqlite3 db.sqlite3 .dump > backup.sql
+```
+
+As this is a plain text file you can commit it to any revision management system, like git.
+Using git you can commit the changes, followed by a git push to a remote repository.
+
+
--- a/docs/how-to.md
+++ b/docs/how-to.md
@@ -0,0 +1,46 @@
+# How To
+
+Collection of tips and tricks around using linkding.
+
+## Using the bookmarklet on Android/Chrome
+
+This how-to explains the usage of the standard linkding bookmarklet on Android / Chrome. 
+
+Chrome on Android does not permit running bookmarklets in the same way you can on a desktop system. There is however a workaround that is explained here.
+
+**Note** that this only works with Chrome and not with other browsers on Android.
+
+Create a bookmark of your linkding deployment by clicking the star icon which you find in the three dots menu in the top right. Next you have to edit the bookmark. Edit the URL and replace it it with the bookmarklet code of your instance and give it an easy to type name like `bm` for bookmark or `ld` for linkding:
+
+```
+javascript: (function() { var bookmarkUrl = window.location; var applicationUrl = 'http://<YOUR_INSTANCE_HERE>/bookmarks/new'; applicationUrl += '?url=' + encodeURIComponent(bookmarkUrl); applicationUrl += '&auto_close'; window.open(applicationUrl);})();
+```
+
+Now when you are browsing the web and you want to save the current page as a bookmark to your linkding instance simply type `bm` into the address bar and select it from the results. The bookmarklet code will trigger and you will be redirected so save the current page.
+
+For more info see here: https://paul.kinlan.me/use-bookmarklets-on-chrome-on-android/
+
+## Create a share action on iOS for adding bookmarks to linkding
+
+This how-to explains how to make use of the app shortcuts iOS app to create a share action that can be used in Safari for adding bookmarks to your linkding instance.
+
+**In the shortcuts app:**
+- create new shortcut
+- go to shortcut details, enable to option to show the shortcut in share menu
+- from the available share input types only select "URL"
+- add Safari action "Display website in Safari" (paraphrasing, not sure how it's called in english)
+- for URL enter your linkding instance URL and specifically point to the new bookmark form, then add the shortcut input variable from the list of suggested variables after the URL parameter. Visually it should look something like this: `https://linkding.mydomain.com/bookmarks/new?url=[Shortcut input]`, where `[Shortcut input]` is a visual block that was inserted after selecting the shortcut input variable suggestion. This is basically a placeholder that will get replaced with the actual URL that you want to bookmark. See screenshot at the end for an example on how this looks.
+- save, give the shortcut a nice name + glyph
+
+Example of how the shortcut configuration should look:
+
+![Screenshot](/docs/ios-app-shortcut-example.png?raw=true "Screenshot demonstrating how to insert the input placeholder into the URL")
+
+**Using the share action from Safari:**
+- browse to the website that you want to share
+- click the share button
+- your new app shortcut should now be available as share action
+- select the app shortcut
+- this should open a new Safari overlay showing the add bookmark form with the URL field prefilled
+- after saving the bookmark you can close the overlay and continue browsing
+
--- a/docs/ios-app-shortcut-example.png
+++ b/docs/ios-app-shortcut-example.png
--- a/docs/linkding-screenshot.png
+++ b/docs/linkding-screenshot.png
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
  "name": "linkding",
-  "version": "1.3.2",
+  "version": "1.7.2",
  "description": "",
  "main": "index.js",
  "scripts": {
--- a/requirements.prod.txt
+++ b/requirements.prod.txt
@@ -1,23 +1,22 @@
+asgiref==3.4.1
 beautifulsoup4==4.7.1
 certifi==2019.6.16
-chardet==3.0.4
-Django==2.2.13
-django-appconf==1.0.3
-django-compressor==2.3
+charset-normalizer==2.0.4
+confusable-homoglyphs==3.2.0
+Django==3.2.6
 django-generate-secret-key==1.0.2
-django-picklefield==2.0
-django-registration==3.0.1
-django-sass-processor==0.7.3
-django-widget-tweaks==1.4.5
-djangorestframework==3.11.1
+django-picklefield==3.0.1
+django-registration==3.2
+django-sass-processor==1.0.1
+django-widget-tweaks==1.4.8
+djangorestframework==3.12.4
 idna==2.8
 pyparsing==2.4.7
-pytz==2019.1
-rcssmin==1.0.6
-requests==2.22.0
-rjsmin==1.1.0
-six==1.12.0
+python-dateutil==2.8.1
+pytz==2021.1
+requests==2.26.0
 soupsieve==1.9.2
-sqlparse==0.3.0
-urllib3==1.25.3
+sqlparse==0.4.1
+typing-extensions==3.10.0.0
+urllib3==1.26.6
 uWSGI==2.0.18
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,24 +1,29 @@
+asgiref==3.4.1
 beautifulsoup4==4.7.1
 certifi==2019.6.16
-chardet==3.0.4
+charset-normalizer==2.0.4
 confusable-homoglyphs==3.2.0
-Django==2.2.13
-django-appconf==1.0.3
-django-compressor==2.3
+coverage==5.5
+Django==3.2.6
+django-appconf==1.0.4
+django-compressor==2.4.1
+django-debug-toolbar==3.2.1
 django-generate-secret-key==1.0.2
-django-picklefield==2.0
-django-registration==3.0.1
-django-sass-processor==0.7.3
-django-widget-tweaks==1.4.5
-djangorestframework==3.11.1
+django-picklefield==3.0.1
+django-registration==3.2
+django-sass-processor==1.0.1
+django-widget-tweaks==1.4.8
+djangorestframework==3.12.4
 idna==2.8
-libsass==0.19.2
+libsass==0.21.0
 pyparsing==2.4.7
-pytz==2019.1
+python-dateutil==2.8.1
+pytz==2021.1
 rcssmin==1.0.6
-requests==2.22.0
+requests==2.26.0
 rjsmin==1.1.0
-six==1.12.0
+six==1.16.0
 soupsieve==1.9.2
-sqlparse==0.3.0
-urllib3==1.25.3
+sqlparse==0.4.1
+typing-extensions==3.10.0.0
+urllib3==1.26.6
--- a/siteroot/settings/base.py
+++ b/siteroot/settings/base.py
@@ -41,7 +41,7 @@ INSTALLED_APPS = [
    'widget_tweaks',
    'django_generate_secret_key',
    'rest_framework',
-    'rest_framework.authtoken'
+    'rest_framework.authtoken',
 ]

 MIDDLEWARE = [
@@ -52,6 +52,7 @@ MIDDLEWARE = [
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
+    'django.middleware.locale.LocaleMiddleware',
 ]

 ROOT_URLCONF = 'siteroot.urls'
@@ -72,6 +73,8 @@ TEMPLATES = [
    },
 ]

+DEFAULT_AUTO_FIELD = 'django.db.models.AutoField'
+
 WSGI_APPLICATION = 'siteroot.wsgi.application'

 # Database
--- a/siteroot/settings/dev.py
+++ b/siteroot/settings/dev.py
@@ -11,6 +11,14 @@ DEBUG = True
 # Turn on SASS compilation
 SASS_PROCESSOR_ENABLED = True

+# Enable debug toolbar
+INSTALLED_APPS.append('debug_toolbar')
+MIDDLEWARE.append('debug_toolbar.middleware.DebugToolbarMiddleware')
+
+INTERNAL_IPS = [
+    '127.0.0.1',
+]
+
 # Enable debug logging
 LOGGING = {
    'version': 1,
--- a/siteroot/urls.py
+++ b/siteroot/urls.py
@@ -13,13 +13,14 @@ 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.contrib import admin
 from django.contrib.auth import views as auth_views
 from django.urls import path, include
-from .settings import ALLOW_REGISTRATION
+
+from bookmarks.admin import linkding_admin_site
+from .settings import ALLOW_REGISTRATION, DEBUG

 urlpatterns = [
-    path('admin/', admin.site.urls),
+    path('admin/', linkding_admin_site.urls),
    path('login/', auth_views.LoginView.as_view(redirect_authenticated_user=True,
                                                extra_context=dict(allow_registration=ALLOW_REGISTRATION)),
         name='login'),
@@ -27,5 +28,9 @@ urlpatterns = [
    path('', include('bookmarks.urls')),
 ]

+if DEBUG:
+    import debug_toolbar
+    urlpatterns.append(path('__debug__/', include(debug_toolbar.urls)))
+
 if ALLOW_REGISTRATION:
    urlpatterns.append(path('', include('django_registration.backends.one_step.urls')))
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Sascha Ißbrücker	076c5d7658	Bump version	2021-08-26 12:40:03 +02:00
Sascha Ißbrücker	e47c00bd07	Add support for micro-, nanosecond timestamps in importer (#151 )	2021-08-26 12:33:54 +02:00
Sascha Ißbrücker	55a0d189dd	Update CHANGELOG.md	2021-08-25 12:36:38 +02:00
Sascha Ißbrücker	d39ce076ec	Bump version	2021-08-25 10:25:22 +02:00
Chris Cesare	aa0258d3b6	remove duplicate word in README (#136 )	2021-08-25 10:20:35 +02:00
Taku Izumi	937858cf58	Fix website scraper decoding content incorrectly (#126 ) * Avoid stall on web scraping This patch fixes stall on web scraping. I encountered a stall (scraping never ends) when adding a bookmark of some site. To avoid this case, adding a timeout parameter at requests.get() function is a solution. Signed-off-by: Taku Izumi <admin@orz-style.com> * Avoid character corruption of scraping some Japanese sites This patch fixes character corruption of scraping some Japanese sites. To avoid character corruption, I use r.content instead of r.text in load_page function. The reason of character corruption is encoding problem, I think. r.text handles data as unicode encoded text, so if scraping web site's charset is not unicode encoded, character corruption occurs. r.content handles data as str[], we can avoid encoding problem. Signed-off-by: Taku Izumi <admin@orz-style.com> * use charset_normalizer to determine response encoding Co-authored-by: Taku Izumi <admin@orz-style.com> Co-authored-by: Sascha Ißbrücker <sascha.issbruecker@googlemail.com>	2021-08-25 10:16:23 +02:00
Sascha Ißbrücker	8047ba6c63	Fix importer not validating bookmark models (#149 )	2021-08-25 09:20:01 +02:00
Damanpreet Singh	de903bc341	Add about section in settings (#134 ) * About section in settings * Added about section in settings tab * fix code style Co-authored-by: Sascha Ißbrücker <sascha.issbruecker@googlemail.com>	2021-08-24 19:47:58 +02:00
Sascha Ißbrücker	c8fcc426b0	Update CHANGELOG.md	2021-08-17 06:07:40 +02:00
Sascha Ißbrücker	eb915210d3	Update CHANGELOG.md	2021-08-17 06:02:07 +02:00
Sascha Ißbrücker	ad9a0f84f2	Bump version	2021-08-17 05:53:25 +02:00
Sascha Ißbrücker	cc04a17e2f	Upgrade Django major (#144 ) * Bump dependency versions * Configure default auto field implementation * fix admin to use token proxy model * update django docs link	2021-08-17 05:48:45 +02:00
Thomas Bouve	69105d3d3c	Support running container as an arbitrary user of the root group (#138 ) * Support OpenShift containers. * Improve comment wording Co-authored-by: Sascha Ißbrücker <sascha.issbruecker@googlemail.com>	2021-08-16 09:16:24 +02:00
Sascha Ißbrücker	c269d16855	Update CHANGELOG.md	2021-08-15 10:47:46 +02:00
Sascha Ißbrücker	90ee3cdb94	Update CHANGELOG.md	2021-08-15 10:46:23 +02:00
Sascha Ißbrücker	2c19266ef8	bump version	2021-08-15 09:52:25 +02:00
ulixxe	048a8b1162	improve tag query performance (#142 ) * changed query on tag search for speedup related to issues #112 and #141 * fix tests and only conditionally append tag filter * add bookmark tags query tests * reuse bookmark queries for tag queries * fix tag query test setup Co-authored-by: Sascha Ißbrücker <sascha.issbruecker@googlemail.com>	2021-08-15 09:28:40 +02:00
Sascha Ißbrücker	2fb0bb1224	Exclude tests from coverage	2021-05-14 23:45:32 +02:00
Sascha Ißbrücker	3e48b22095	Add settings view tests	2021-05-14 23:34:53 +02:00
Sascha Ißbrücker	9aa17d0528	Add code coverage script	2021-05-14 12:23:11 +02:00
Sascha Ißbrücker	d643fca98f	Add query tests	2021-05-14 10:26:33 +02:00
Sascha Ißbrücker	f293fa15bc	Update CI config to install Node dependencies	2021-05-14 02:38:44 +02:00
Sascha Ißbrücker	f58434077b	Add bookmark view tests	2021-05-14 02:32:19 +02:00
Sascha Ißbrücker	59641e787c	Update CHANGELOG.md	2021-05-13 20:09:53 +02:00
Sascha Ißbrücker	0d36a3bb86	Update CHANGELOG.md	2021-05-13 19:21:21 +02:00
Sascha Ißbrücker	b25f3d5529	Bump version	2021-05-13 18:29:46 +02:00
mattofr	24746deaae	Admin documentation (#91 ) * Started admin documentation * Small correction * Polish admin docs and reference from README.md Co-authored-by: emacs <emacs@hp2530p.tradesystem.nl> Co-authored-by: Sascha Ißbrücker <sascha.issbruecker@googlemail.com>	2021-05-13 18:28:25 +02:00
André Kelpe	e4a082231f	Add how-to document (#102 ) * adds how-to for using the bookmarklet on Android/Chrome * Polish how-to doc and reference from README.md * Add how-to for creating share action in Safari Co-authored-by: Sascha Ißbrücker <sascha.issbruecker@googlemail.com>	2021-05-13 17:52:13 +02:00
dependabot[bot]	5a380212d9	Bump django from 2.2.18 to 2.2.20 (#110 ) Bumps [django](https://github.com/django/django) from 2.2.18 to 2.2.20. - [Release notes](https://github.com/django/django/releases) - [Commits](https://github.com/django/django/compare/2.2.18...2.2.20) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2021-05-13 17:23:37 +02:00
dependabot[bot]	96068719cd	Bump urllib3 from 1.25.3 to 1.25.8 (#119 ) Bumps [urllib3](https://github.com/urllib3/urllib3) from 1.25.3 to 1.25.8. - [Release notes](https://github.com/urllib3/urllib3/releases) - [Changelog](https://github.com/urllib3/urllib3/blob/main/CHANGES.rst) - [Commits](https://github.com/urllib3/urllib3/compare/1.25.3...1.25.8) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2021-05-13 17:21:27 +02:00
dependabot[bot]	e42d562750	Bump django-debug-toolbar from 3.2 to 3.2.1 (#115 ) Bumps [django-debug-toolbar](https://github.com/jazzband/django-debug-toolbar) from 3.2 to 3.2.1. - [Release notes](https://github.com/jazzband/django-debug-toolbar/releases) - [Changelog](https://github.com/jazzband/django-debug-toolbar/blob/main/docs/changes.rst) - [Commits](https://github.com/jazzband/django-debug-toolbar/compare/3.2...3.2.1) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2021-05-13 17:17:51 +02:00
dependabot[bot]	ff456b10ee	Bump django-registration from 3.0.1 to 3.1.2 (#106 ) Bumps [django-registration](https://github.com/ubernostrum/django-registration) from 3.0.1 to 3.1.2. - [Release notes](https://github.com/ubernostrum/django-registration/releases) - [Commits](https://github.com/ubernostrum/django-registration/compare/3.0.1...3.1.2) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2021-05-13 17:13:36 +02:00
Sascha Ißbrücker	3a05666680	Update CHANGELOG.md	2021-04-07 00:43:39 +02:00
Sascha Ißbrücker	dbe92b4b84	Bump version	2021-04-06 23:39:02 +02:00
Sascha Ißbrücker	90f62d3482	Fix relative date formatting (#107 )	2021-04-06 23:38:15 +02:00
Sascha Ißbrücker	847f9644f4	Update CHANGELOG.md	2021-04-04 10:31:48 +02:00
Sascha Ißbrücker	bf84b3ddfd	Bump version	2021-04-04 10:17:12 +02:00
Sascha Ißbrücker	2d19e97212	Allow editing of scraped values (#80 ) * Allow editing scraped title + description (#80) * Fix edit button hijacking form submit	2021-04-04 10:16:40 +02:00
Sascha Ißbrücker	c083997399	Update CHANGELOG.md	2021-03-31 09:23:06 +02:00
Sascha Ißbrücker	36f134db9a	Update CHANGELOG.md	2021-03-31 09:11:59 +02:00
Sascha Ißbrücker	593d90d8e2	Bump version	2021-03-31 09:09:08 +02:00
Sascha Ißbrücker	7a68a4abed	Display date_added in bookmark list (#85 ) * Display date_added in bookmark list (#85) * Allow switching between different types of date formats * Improve date formatting * Use pluralize * Fix comment * Fix styles Co-authored-by: Sascha Ißbrücker <sissbruecker@lyska.io>	2021-03-31 09:08:19 +02:00
Sascha Ißbrücker	8dd1575dc6	Update CHANGELOG.md	2021-03-29 01:04:00 +02:00
Sascha Ißbrücker	d4d23daebc	Update CHANGELOG.md	2021-03-29 00:59:56 +02:00
Sascha Ißbrücker	a73910d9c7	Bump version	2021-03-29 00:57:15 +02:00
Sascha Ißbrücker	0c1c21c8d1	Implement bulk edit (#101 )	2021-03-29 00:43:50 +02:00
Sascha Ißbrücker	2e4f271490	Update CHANGELOG.md	2021-03-28 12:27:38 +02:00
Sascha Ißbrücker	61b13dc531	Update CHANGELOG.md	2021-03-28 12:26:09 +02:00
Sascha Ißbrücker	e976fd054c	Bump version	2021-03-28 12:14:11 +02:00
Sascha Ißbrücker	119d8f7efb	Implement dark theme (#49 )	2021-03-28 12:11:56 +02:00
Sascha Ißbrücker	3e5e825032	Update CHANGELOG.md	2021-03-20 12:41:47 +01:00
Sascha Ißbrücker	dc1f6f9c44	Update CHANGELOG.md	2021-03-20 12:39:15 +01:00
Sascha Ißbrücker	9e0114ea49	Bump version	2021-03-20 12:36:30 +01:00
Sascha Ißbrücker	84508e07cd	Doc improvements (#97 ) * Improve docs * Improve docs	2021-03-20 11:58:20 +01:00
mattofr	496c5badbf	Add backup document (#89 ) * Added backup document * Improve and reference backup docs Co-authored-by: matto <matto@matto.nl> Co-authored-by: Sascha Ißbrücker <sissbruecker@lyska.io>	2021-03-20 07:01:19 +01:00
dependabot[bot]	1c5d92dc73	Bump djangorestframework from 3.11.1 to 3.11.2 (#96 ) Bumps [djangorestframework](https://github.com/encode/django-rest-framework) from 3.11.1 to 3.11.2. - [Release notes](https://github.com/encode/django-rest-framework/releases) - [Commits](https://github.com/encode/django-rest-framework/compare/3.11.1...3.11.2) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2021-03-20 05:58:58 +01:00
dependabot[bot]	b11444f98e	Bump django from 2.2.13 to 2.2.18 (#94 ) Bumps [django](https://github.com/django/django) from 2.2.13 to 2.2.18. - [Release notes](https://github.com/django/django/releases) - [Commits](https://github.com/django/django/compare/2.2.13...2.2.18) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2021-03-20 05:58:35 +01:00
stranger-danger-zamu	ad070e7019	Multistage Dockerfile (#90 ) * Multistage Dockerfile * Fix final stage and improve image size + layer caching Co-authored-by: Sascha Ißbrücker <sissbruecker@lyska.io>	2021-03-13 11:24:44 +01:00
Sascha Ißbrücker	6880c9ee56	Update CHANGELOG.md	2021-02-24 03:49:43 +01:00
Sascha Ißbrücker	e773ad1dc4	Bump version	2021-02-24 03:37:25 +01:00
Sascha Ißbrücker	a02338cdec	Improve and promote admin panel (#76 ) * Improve and promote admin panel (#76) * Customize admin panel texts (#76) * Improve settings structure (#76) * Improve admin list consistency (#76) * Fix redirect URLs (#76) * Add admin tooltip (#76)	2021-02-24 03:36:27 +01:00
Sascha Ißbrücker	8c161ba119	Implement bookmark API tests	2021-02-20 09:01:38 +01:00
Sascha Ißbrücker	5644dae14e	Update CHANGELOG.md	2021-02-18 22:12:02 +01:00
Sascha Ißbrücker	58836c3c76	Bump version	2021-02-18 22:11:09 +01:00
Sascha Ißbrücker	b7a8f9e53d	Mark optional fields in bookmark serializer (#78 )	2021-02-18 22:02:45 +01:00
Sascha Ißbrücker	afe081d3b5	Update CHANGELOG.md	2021-02-18 07:39:40 +01:00
				`@@ -0,0 +1 @@`
				`<input id="bulk-edit-mode" type="checkbox">`