django-reorder-items-widget 1.0.0__tar.gz

django_reorder_items_widget-1.0.0/LICENCE

@@ -0,0 +1,27 @@
+Copyright (c) 2024, Thomas Leichtfuß.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+    1. Redistributions of source code must retain the above copyright notice,
+       this list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above copyright
+       notice, this list of conditions and the following disclaimer in the
+       documentation and/or other materials provided with the distribution.
+
+    3. Neither the name of the author nor the names of contributors
+       may be used to endorse or promote products derived from this software
+       without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

django_reorder_items_widget-1.0.0/PKG-INFO

@@ -0,0 +1,131 @@
+Metadata-Version: 2.4
+Name: django-reorder-items-widget
+Version: 1.0.0
+Summary: Easily reorder the order of items within the django admin backend.
+Author-email: Thomas Leichtfuß <thomas.leichtfuss@posteo.de>
+License: BSD-3-Clause
+Project-URL: Homepage, https://github.com/thomst/django-reorder-items-widget
+Project-URL: Repository, https://github.com/thomst/django-reorder-items-widget
+Project-URL: Documentation, https://github.com/thomst/django-reorder-items-widget#readme
+Keywords: django,django-admin,widgets
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 3.2
+Classifier: Framework :: Django :: 4.0
+Classifier: Framework :: Django :: 4.1
+Classifier: Framework :: Django :: 4.2
+Classifier: Framework :: Django :: 5.0
+Classifier: Framework :: Django :: 5.1
+Classifier: Framework :: Django :: 5.2
+Classifier: Framework :: Django :: 6.0
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENCE
+Requires-Dist: Django>=3.2
+Dynamic: license-file
+
+# Welcome to django-reorder-items-widget
+
+[![Tests](https://github.com/thomst/django-reorder-items-widget/actions/workflows/tests.yml/badge.svg)](https://github.com/thomst/django-reorder-items-widget/actions/workflows/tests.yml)
+[<img src="https://coveralls.io/repos/github/thomst/django-reorder-items-widget/badge.svg?branch=main">](https://coveralls.io/github/thomst/django-reorder-items-widget?branch=main)
+[<img src="https://img.shields.io/badge/python-3-blue">](https://img.shields.io/badge/python-3-blue)
+[<img src="https://img.shields.io/badge/django-3.2%20%7C%204.0%20%7C%204.1%20%7C%204.2%20%7C%205.0%20%7C%205.1%20%7C%205.2%20%7C%206.0-orange">](https://img.shields.io/badge/django-3.2%20%7C%204.0%20%7C%204.1%20%7C%204.2%20%7C%205.0%20%7C%205.1%20%7C%205.2%20%7C%206.0-orange)
+
+
+## Description
+
+Reorder your items by simply dragging them to their new position. This works
+fine within django admin's changelists or inline model forms.
+
+All you need to do is to use an editable index field with the famous
+`ReorderItemsWidget` of this app.
+
+
+## Installation
+
+Install via pip:
+```
+pip install django-reorder-items-widget
+```
+
+## Setup
+
+Add `reorder_items_widget` to your `INSTALLED_APPS`:
+```
+INSTALLED_APPS = [
+    'reorder_items_widget',
+    ...
+]
+```
+
+Add a index field to your model:
+```
+class Item(models.Model):
+    index = models.PositiveSmallIntegerField()
+    ...
+    class Meta:
+        ordering = ('index',)
+```
+
+Using the ReorderItemsWidget with your index field only makes sense in result
+lists or inline modeladmin forms. A simple way to put the widget in place is a
+custom model form:
+```
+class ReorderItemForm(forms.ModelForm):
+    class Meta:
+        widgets={'index': ReorderItemsWidget()}
+```
+
+Now you can use this form with your changelist by overwriting the
+`get_changelist_form` method of your model admin:
+```
+class BaseItemAdmin(admin.ModelAdmin):
+    list_editable = ("index",)
+    list_display = ("index", ...)
+
+    def get_changelist_form(self, request, **kwargs):
+        kwargs.setdefault('form', ReorderItemForm)
+        return super().get_changelist_form(request, **kwargs)
+```
+
+**_NOTE:_** Mind that your index field must be editable.
+
+To use the widget with your inline modeladmin simple at your form to the
+`TabularInline` class:
+```
+class ItemInline(admin.TabularInline):
+    form = ReorderItemForm
+    fields = ("index", ...)
+    ...
+```
+
+That's it.
+
+## Caveats
+
+The widget will always number your items sequentially. Reordering items in a
+filtered list might be have unexpected results. Paging however should not be a
+problem since indexes are updated using the lowest one as base.
+
+## General considerations on switching index values
+
+There is a general problem with switching values on a unique index field: In
+mysql like databases you will run into a constraint violation - even if you
+update all items in a single update transaction.
+
+To work around this you can either obmit the unique constraint. Or implement a
+complex saving logic like saving changed indexes as negative values first and
+update them to their positiv counterpart afterwards.
+
+## Contribute
+
+Feedback, feature requests, bug reports or pull requests are most welcome. Just
+use the common github infrastructure.

django_reorder_items_widget-1.0.0/README.md

@@ -0,0 +1,97 @@
+# Welcome to django-reorder-items-widget
+
+[![Tests](https://github.com/thomst/django-reorder-items-widget/actions/workflows/tests.yml/badge.svg)](https://github.com/thomst/django-reorder-items-widget/actions/workflows/tests.yml)
+[<img src="https://coveralls.io/repos/github/thomst/django-reorder-items-widget/badge.svg?branch=main">](https://coveralls.io/github/thomst/django-reorder-items-widget?branch=main)
+[<img src="https://img.shields.io/badge/python-3-blue">](https://img.shields.io/badge/python-3-blue)
+[<img src="https://img.shields.io/badge/django-3.2%20%7C%204.0%20%7C%204.1%20%7C%204.2%20%7C%205.0%20%7C%205.1%20%7C%205.2%20%7C%206.0-orange">](https://img.shields.io/badge/django-3.2%20%7C%204.0%20%7C%204.1%20%7C%204.2%20%7C%205.0%20%7C%205.1%20%7C%205.2%20%7C%206.0-orange)
+
+
+## Description
+
+Reorder your items by simply dragging them to their new position. This works
+fine within django admin's changelists or inline model forms.
+
+All you need to do is to use an editable index field with the famous
+`ReorderItemsWidget` of this app.
+
+
+## Installation
+
+Install via pip:
+```
+pip install django-reorder-items-widget
+```
+
+## Setup
+
+Add `reorder_items_widget` to your `INSTALLED_APPS`:
+```
+INSTALLED_APPS = [
+    'reorder_items_widget',
+    ...
+]
+```
+
+Add a index field to your model:
+```
+class Item(models.Model):
+    index = models.PositiveSmallIntegerField()
+    ...
+    class Meta:
+        ordering = ('index',)
+```
+
+Using the ReorderItemsWidget with your index field only makes sense in result
+lists or inline modeladmin forms. A simple way to put the widget in place is a
+custom model form:
+```
+class ReorderItemForm(forms.ModelForm):
+    class Meta:
+        widgets={'index': ReorderItemsWidget()}
+```
+
+Now you can use this form with your changelist by overwriting the
+`get_changelist_form` method of your model admin:
+```
+class BaseItemAdmin(admin.ModelAdmin):
+    list_editable = ("index",)
+    list_display = ("index", ...)
+
+    def get_changelist_form(self, request, **kwargs):
+        kwargs.setdefault('form', ReorderItemForm)
+        return super().get_changelist_form(request, **kwargs)
+```
+
+**_NOTE:_** Mind that your index field must be editable.
+
+To use the widget with your inline modeladmin simple at your form to the
+`TabularInline` class:
+```
+class ItemInline(admin.TabularInline):
+    form = ReorderItemForm
+    fields = ("index", ...)
+    ...
+```
+
+That's it.
+
+## Caveats
+
+The widget will always number your items sequentially. Reordering items in a
+filtered list might be have unexpected results. Paging however should not be a
+problem since indexes are updated using the lowest one as base.
+
+## General considerations on switching index values
+
+There is a general problem with switching values on a unique index field: In
+mysql like databases you will run into a constraint violation - even if you
+update all items in a single update transaction.
+
+To work around this you can either obmit the unique constraint. Or implement a
+complex saving logic like saving changed indexes as negative values first and
+update them to their positiv counterpart afterwards.
+
+## Contribute
+
+Feedback, feature requests, bug reports or pull requests are most welcome. Just
+use the common github infrastructure.

django_reorder_items_widget-1.0.0/django_reorder_items_widget.egg-info/PKG-INFO

@@ -0,0 +1,131 @@
+Metadata-Version: 2.4
+Name: django-reorder-items-widget
+Version: 1.0.0
+Summary: Easily reorder the order of items within the django admin backend.
+Author-email: Thomas Leichtfuß <thomas.leichtfuss@posteo.de>
+License: BSD-3-Clause
+Project-URL: Homepage, https://github.com/thomst/django-reorder-items-widget
+Project-URL: Repository, https://github.com/thomst/django-reorder-items-widget
+Project-URL: Documentation, https://github.com/thomst/django-reorder-items-widget#readme
+Keywords: django,django-admin,widgets
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 3.2
+Classifier: Framework :: Django :: 4.0
+Classifier: Framework :: Django :: 4.1
+Classifier: Framework :: Django :: 4.2
+Classifier: Framework :: Django :: 5.0
+Classifier: Framework :: Django :: 5.1
+Classifier: Framework :: Django :: 5.2
+Classifier: Framework :: Django :: 6.0
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENCE
+Requires-Dist: Django>=3.2
+Dynamic: license-file
+
+# Welcome to django-reorder-items-widget
+
+[![Tests](https://github.com/thomst/django-reorder-items-widget/actions/workflows/tests.yml/badge.svg)](https://github.com/thomst/django-reorder-items-widget/actions/workflows/tests.yml)
+[<img src="https://coveralls.io/repos/github/thomst/django-reorder-items-widget/badge.svg?branch=main">](https://coveralls.io/github/thomst/django-reorder-items-widget?branch=main)
+[<img src="https://img.shields.io/badge/python-3-blue">](https://img.shields.io/badge/python-3-blue)
+[<img src="https://img.shields.io/badge/django-3.2%20%7C%204.0%20%7C%204.1%20%7C%204.2%20%7C%205.0%20%7C%205.1%20%7C%205.2%20%7C%206.0-orange">](https://img.shields.io/badge/django-3.2%20%7C%204.0%20%7C%204.1%20%7C%204.2%20%7C%205.0%20%7C%205.1%20%7C%205.2%20%7C%206.0-orange)
+
+
+## Description
+
+Reorder your items by simply dragging them to their new position. This works
+fine within django admin's changelists or inline model forms.
+
+All you need to do is to use an editable index field with the famous
+`ReorderItemsWidget` of this app.
+
+
+## Installation
+
+Install via pip:
+```
+pip install django-reorder-items-widget
+```
+
+## Setup
+
+Add `reorder_items_widget` to your `INSTALLED_APPS`:
+```
+INSTALLED_APPS = [
+    'reorder_items_widget',
+    ...
+]
+```
+
+Add a index field to your model:
+```
+class Item(models.Model):
+    index = models.PositiveSmallIntegerField()
+    ...
+    class Meta:
+        ordering = ('index',)
+```
+
+Using the ReorderItemsWidget with your index field only makes sense in result
+lists or inline modeladmin forms. A simple way to put the widget in place is a
+custom model form:
+```
+class ReorderItemForm(forms.ModelForm):
+    class Meta:
+        widgets={'index': ReorderItemsWidget()}
+```
+
+Now you can use this form with your changelist by overwriting the
+`get_changelist_form` method of your model admin:
+```
+class BaseItemAdmin(admin.ModelAdmin):
+    list_editable = ("index",)
+    list_display = ("index", ...)
+
+    def get_changelist_form(self, request, **kwargs):
+        kwargs.setdefault('form', ReorderItemForm)
+        return super().get_changelist_form(request, **kwargs)
+```
+
+**_NOTE:_** Mind that your index field must be editable.
+
+To use the widget with your inline modeladmin simple at your form to the
+`TabularInline` class:
+```
+class ItemInline(admin.TabularInline):
+    form = ReorderItemForm
+    fields = ("index", ...)
+    ...
+```
+
+That's it.
+
+## Caveats
+
+The widget will always number your items sequentially. Reordering items in a
+filtered list might be have unexpected results. Paging however should not be a
+problem since indexes are updated using the lowest one as base.
+
+## General considerations on switching index values
+
+There is a general problem with switching values on a unique index field: In
+mysql like databases you will run into a constraint violation - even if you
+update all items in a single update transaction.
+
+To work around this you can either obmit the unique constraint. Or implement a
+complex saving logic like saving changed indexes as negative values first and
+update them to their positiv counterpart afterwards.
+
+## Contribute
+
+Feedback, feature requests, bug reports or pull requests are most welcome. Just
+use the common github infrastructure.

django_reorder_items_widget-1.0.0/django_reorder_items_widget.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENCE
+README.md
+pyproject.toml
+django_reorder_items_widget.egg-info/PKG-INFO
+django_reorder_items_widget.egg-info/SOURCES.txt
+django_reorder_items_widget.egg-info/dependency_links.txt
+django_reorder_items_widget.egg-info/requires.txt
+django_reorder_items_widget.egg-info/top_level.txt
+reorder_items_widget/__init__.py
+reorder_items_widget/__version__.py
+reorder_items_widget/apps.py
+reorder_items_widget/tests.py
+reorder_items_widget/widgets.py
+reorder_items_widget/static/css/reorder-items-widget.css
+reorder_items_widget/static/js/reorder-items-widget.js
+reorder_items_widget/templates/forms/widgets/reorder-items-widget.html
+reorder_items_widget/templatetags/__init__.py
+reorder_items_widget/templatetags/reorder_items_widget.py

django_reorder_items_widget-1.0.0/django_reorder_items_widget.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

django_reorder_items_widget-1.0.0/django_reorder_items_widget.egg-info/requires.txt

@@ -0,0 +1 @@
+Django>=3.2

django_reorder_items_widget-1.0.0/django_reorder_items_widget.egg-info/top_level.txt

@@ -0,0 +1 @@
+reorder_items_widget

django_reorder_items_widget-1.0.0/pyproject.toml

@@ -0,0 +1,51 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "django-reorder-items-widget"
+authors = [{name = "Thomas Leichtfuß", email = "thomas.leichtfuss@posteo.de"}]
+description = "Easily reorder the order of items within the django admin backend."
+readme = "README.md"
+requires-python = ">=3.8"
+keywords = ["django", "django-admin", "widgets"]
+license = { text = "BSD-3-Clause"}
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Framework :: Django",
+    "Framework :: Django :: 3.2",
+    "Framework :: Django :: 4.0",
+    "Framework :: Django :: 4.1",
+    "Framework :: Django :: 4.2",
+    "Framework :: Django :: 5.0",
+    "Framework :: Django :: 5.1",
+    "Framework :: Django :: 5.2",
+    "Framework :: Django :: 6.0",
+    "Environment :: Web Environment",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Topic :: Internet :: WWW/HTTP :: Dynamic Content",
+    "Topic :: Software Development",
+    "Topic :: Software Development :: Libraries :: Application Frameworks",
+]
+dependencies = [
+    "Django>=3.2",
+]
+dynamic = ["version"]
+
+[project.urls]
+Homepage = "https://github.com/thomst/django-reorder-items-widget"
+Repository = "https://github.com/thomst/django-reorder-items-widget"
+Documentation = "https://github.com/thomst/django-reorder-items-widget#readme"
+
+[tool.setuptools]
+packages = ["reorder_items_widget", "reorder_items_widget.templatetags"]
+include-package-data = false
+
+[tool.setuptools.package-data]
+reorder_items_widget = ["templates/**", "static/**"]
+
+[tool.setuptools.dynamic]
+version = {attr = "reorder_items_widget.__version__.__version__"}

django_reorder_items_widget-1.0.0/reorder_items_widget/__version__.py

@@ -0,0 +1,16 @@
+"""
+This project uses the Semantic Versioning scheme in conjunction with PEP 0440:
+    <http://semver.org/>
+    <https://www.python.org/dev/peps/pep-0440>
+
+Major versions introduce significant changes to the API, and backwards
+compatibility is not guaranteed. Minor versions are for new features and other
+backwards-compatible changes to the API. Patch versions are for bug fixes and
+internal code changes that do not affect the API. Development versions are
+incomplete states of a release .
+
+Version 0.x should be considered a development version with an unstable API,
+and backwards compatibility is not guaranteed for minor versions.
+"""
+
+__version__ = "1.0.0"

django_reorder_items_widget-1.0.0/reorder_items_widget/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class ReorderItemsWidgetConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'reorder_items_widget'

django_reorder_items_widget-1.0.0/reorder_items_widget/static/css/reorder-items-widget.css

@@ -0,0 +1,9 @@
+.drag-handle {
+    display: inline;
+    cursor: grab;
+    font-size: 180%;
+}
+
+.on-drag {
+    opacity: 50%;
+}

django_reorder_items_widget-1.0.0/reorder_items_widget/static/js/reorder-items-widget.js

@@ -0,0 +1,136 @@
+(function() {
+    "use strict";
+
+    class ReorderItemsTable {
+
+        constructor (table) {
+            this.table = table;
+            this.form = table.closest('form');
+            this.baseIndex = Number(table.querySelector('.reorder-items-widget-index').value);
+            const style = window.getComputedStyle(table.querySelector('tbody > tr'))
+            this.rowHeight = style.getPropertyValue('height');
+            this.initRows();
+            this.initHeaderAsDragOverAndDropZone();
+            this.initFormSubmission();
+        }
+
+        getRows() {
+            var selector;
+            if (this.table.id == 'result_list') {
+                selector = 'tbody > tr';
+            } else {
+                selector = 'tbody > tr.has_original'
+            }
+            return this.table.querySelectorAll(selector);
+        }
+
+        initRows() {
+            [].forEach.call(this.getRows(), (row) => {
+                this.initRowAsDragOver(row);
+                this.initRowAsDropZone(row);
+                this.initRowAsDraggable(row);
+            });
+        }
+
+        initRowAsDragOver(row) {
+            var counter = 0
+            const that = this;
+            row.addEventListener("dragenter", function (e) {
+                counter++;
+                // The hovering row is not itself or the one above - which also
+                // could be the header.
+                const firstRow = that.table.querySelector('tbody > tr');
+                if (
+                    !row.draggable &&
+                    !(row.nextElementSibling && row.nextElementSibling.draggable) &&
+                    !(row.parentElement.nodeName == 'THEAD' && firstRow.draggable)
+                ) that.addDragOverStyle(row);
+            });
+            row.addEventListener("dragleave", function (e) {
+                counter--;
+                if (counter == 0)
+                    that.removeDragOverStyle(row);
+            });
+            row.addEventListener("drop", function (e) {
+                counter = 0;
+                that.removeDragOverStyle(row);
+            });
+        }
+
+        addDragOverStyle(row) {
+            row.style.borderBottom = `${this.rowHeight} solid var(--selected-bg)`;
+        }
+
+        removeDragOverStyle(row) {
+            row.style.borderBottom = 0;
+        }
+
+        initRowAsDropZone(row) {
+            row.addEventListener("dragover", function (e) {
+                e.preventDefault();
+            });
+            row.addEventListener("drop", function (e) {
+                e.preventDefault();
+                const inputID = e.dataTransfer.getData("text");
+                const draggedRow = document.getElementById(inputID).closest('tr');
+                row.after(draggedRow);
+            });
+        }
+
+        initRowAsDraggable(row) {
+            const handle = row.querySelector('.drag-handle');
+            handle.addEventListener("mousedown", function (e) {
+                row.setAttribute('draggable', 'true');
+            });
+            handle.addEventListener("mouseup", function(e) {
+                row.setAttribute('draggable', 'false');
+            });
+            row.addEventListener("dragstart", function (e) {
+                row.classList.add("on-drag");
+                const inputID = row.querySelector('input.reorder-items-widget-index').id;
+                e.dataTransfer.setData("text", inputID);
+            });
+            row.addEventListener("dragend", function (e) {
+                row.classList.remove("on-drag");
+                row.setAttribute('draggable', 'false');
+            });
+        }
+
+        initHeaderAsDragOverAndDropZone() {
+            const row = this.table.querySelector('thead > tr');
+            this.initRowAsDragOver(row);
+            row.addEventListener("dragover", function (e) {
+                e.preventDefault();
+            });
+            const querySelector = this.table.querySelector.bind(this.table);
+            row.addEventListener("drop", function (e) {
+                e.preventDefault();
+                const inputID = e.dataTransfer.getData("text");
+                const draggedRow = document.getElementById(inputID).closest('tr');
+                const firstRow = querySelector('tbody > tr');
+                firstRow.before(draggedRow);
+            });
+        }
+
+        initFormSubmission() {
+            const that = this;
+            this.form.addEventListener("submit", function (e) {
+                [].forEach.call(that.getRows(), (row, counter) => {
+                    const index = that.baseIndex + counter;
+                    row.querySelector('.reorder-items-widget-index').value = index;
+                });
+            });
+        }
+    }
+
+
+    document.addEventListener("DOMContentLoaded", function () {
+        // Init each table which uses the reorder-items-widget.
+        document.querySelectorAll('table').forEach((el) => {
+            if (el.querySelector('.drag-handle')) {
+                new ReorderItemsTable(el);
+            }
+        });
+    });
+
+})();

django_reorder_items_widget-1.0.0/reorder_items_widget/templates/forms/widgets/reorder-items-widget.html

@@ -0,0 +1,14 @@
+{% load reorder_items_widget %}
+
+{% comment %}
+We only render the widget for existing items. Doing something smart with the
+index input for extra rows in inline model forms - like using a hidden input and
+set the index within a pre-save signal handler - is not our buisness.
+{% endcomment %}
+
+{% if widget.value %}
+    {% hide_widget %}
+    <div title="Drag me!" class="drag-handle">⇳</div>
+{% endif %}
+
+{% include "django/forms/widgets/input.html" %}

django_reorder_items_widget-1.0.0/reorder_items_widget/templatetags/reorder_items_widget.py

@@ -0,0 +1,9 @@
+from django import template
+
+register = template.Library()
+
+
+@register.simple_tag(takes_context=True)
+def hide_widget(context):
+    context['widget']['attrs']['class'] += ' hidden'
+    return ''

django_reorder_items_widget-1.0.0/reorder_items_widget/tests.py

@@ -0,0 +1,28 @@
+from django.test import TestCase
+from .widgets import ReorderItemsWidget
+
+# Just for coverage score.
+from . import __version__
+
+
+class WidgetTestCase(TestCase):
+    def test_widget(self):
+        widget = ReorderItemsWidget()
+        css_classes = widget.build_attrs(dict(), dict())['class']
+        self.assertIn('reorder-items-widget-index', css_classes)
+
+    def test_rendering_with_value(self):
+        widget = ReorderItemsWidget()
+        html = widget.render('index', 1)
+        input = '<input type="number" name="index" value="1" class="reorder-items-widget-index hidden">'
+        drag_handle = '<div title="Drag me!" class="drag-handle">⇳</div>'
+        self.assertInHTML(input, html)
+        self.assertInHTML(drag_handle, html)
+
+    def test_rendering_without_value(self):
+        widget = ReorderItemsWidget()
+        html = widget.render('index', None)
+        input = '<input type="number" name="index" class="reorder-items-widget-index">'
+        drag_handle = '<div title="Drag me!" class="drag-handle">⇳</div>'
+        self.assertInHTML(input, html)
+        self.assertNotIn(drag_handle, html)

django_reorder_items_widget-1.0.0/reorder_items_widget/widgets.py

@@ -0,0 +1,20 @@
+from django.forms import NumberInput
+
+
+class ReorderItemsWidget(NumberInput):
+    """
+    A widget that allows to move items up and down within a listing with an
+    editable index field.
+    """
+    template_name = 'forms/widgets/reorder-items-widget.html'
+
+    class Media:
+        css = {'all': ('css/reorder-items-widget.css',)}
+        js = ('js/reorder-items-widget.js',)
+
+    def build_attrs(self, base_attrs, extra_attrs):
+        attrs = super().build_attrs(base_attrs, extra_attrs)
+        css_classes = attrs['class'].split(' ') if attrs.get('class') else []
+        css_classes += ['reorder-items-widget-index']
+        attrs['class'] = ' '.join(css_classes)
+        return attrs

django_reorder_items_widget-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+