Bump version

* Allow editing scraped title + description (#80)

* Fix edit button hijacking form submit

CHANGELOG.md

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

README.md

@@ -11,9 +11,10 @@ The name comes from:
 **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
-- Bookmark archive
 - 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
@@ -22,7 +23,7 @@ The name comes from:
 - 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 bulk operations
+- Admin panel for user self-service and raw data access
 
 
 **Demo:** https://demo.linkding.link/ (configured with open registration)

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>
@@ -124,4 +140,17 @@
     .menu.open {
         display: block;
     }
+
+    .form-autocomplete.small .form-autocomplete-input {
+        height: 1.4rem;
+        min-height: 1.4rem;
+    }
+    .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>

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

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

bookmarks/models.py

@@ -107,14 +107,24 @@ class UserProfile(models.Model):
         (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']
+        fields = ['theme', 'bookmark_date_display']
 
 
 @receiver(post_save, sender=get_user_model())

bookmarks/queries.py

@@ -55,8 +55,8 @@ 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
 

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]

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();
+})()

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()
+})()

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 {

bookmarks/styles/bookmarks.scss

@@ -30,6 +30,12 @@
   }
 }
 
+.bookmarks-page .content-area-header {
+  span.btn {
+    margin-left: 8px;
+  }
+}
+
 ul.bookmark-list {
 
   list-style: none;
@@ -44,24 +50,27 @@ ul.bookmark-list {
     }
   }
 
+  .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;
   }
 }
 
@@ -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;
+}

bookmarks/styles/dark.scss

@@ -21,6 +21,11 @@ a:focus, .btn:focus {
   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;

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;
+  }
+}

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;
+}

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 %}

bookmarks/templates/bookmarks/bookmark_list.html

@@ -4,16 +4,20 @@
 <ul class="bookmark-list">
     {% for bookmark in bookmarks %}
         <li>
+            <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>

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>

bookmarks/templates/bookmarks/bulk_edit/state.html

@@ -0,0 +1 @@
+<input id="bulk-edit-mode" type="checkbox">

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>

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>

bookmarks/templates/bookmarks/form.html

@@ -14,12 +14,13 @@
             </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>

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 %}

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' %}"/>

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>

bookmarks/templates/settings/general.html

@@ -15,6 +15,10 @@
                     <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>

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
     }

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)

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.tests.helpers import BookmarkFactoryMixin
+from bookmarks.models import UserProfile
+
+
+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)

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

bookmarks/tests/test_bulk_edit_integration.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 BulkEditIntegrationTests(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])

bookmarks/tests/test_utils.py

@@ -0,0 +1,65 @@
+from unittest.mock import patch
+
+from django.test import TestCase
+from django.utils import timezone
+
+from bookmarks.utils import humanize_absolute_date, humanize_relative_date
+
+
+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')

bookmarks/urls.py

@@ -18,6 +18,7 @@ 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.general, name='settings.index'),
     path('settings/general', views.settings.general, name='settings.general'),

bookmarks/utils.py

@@ -1,2 +1,60 @@
+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()]

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

requirements.prod.txt

@@ -11,6 +11,7 @@ django-widget-tweaks==1.4.5
 djangorestframework==3.11.2
 idna==2.8
 pyparsing==2.4.7
+python-dateutil==2.8.1
 pytz==2019.1
 requests==2.22.0
 soupsieve==1.9.2

requirements.txt

@@ -15,6 +15,7 @@ djangorestframework==3.11.2
 idna==2.8
 libsass==0.19.2
 pyparsing==2.4.7
+python-dateutil==2.8.1
 pytz==2019.1
 rcssmin==1.0.6
 requests==2.22.0

siteroot/settings/base.py

@@ -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'

version.txt

@@ -1 +1 @@
-1.5.0
+1.6.3