django-lineup 1.0.1__py3-none-any.whl

django_lineup-1.0.1.dist-info/METADATA

@@ -0,0 +1,242 @@
+Metadata-Version: 2.4
+Name: django-lineup
+Version: 1.0.1
+Summary: Navigation system for Django sites
+Author-email: Otto <opensource@otto.srl>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/otto-torino/django-lineup
+Project-URL: Documentation, https://django-lineup.readthedocs.io/en/latest/
+Project-URL: Repository, https://github.com/otto-torino/django-lineup
+Project-URL: Bug Tracker, https://github.com/otto-torino/django-lineup/issues
+Keywords: django,navigation,menu,mptt
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 4.2
+Classifier: Framework :: Django :: 5.0
+Classifier: Framework :: Django :: 6.0
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Requires-Dist: Django>=4.2
+Requires-Dist: django-mptt>=0.17.0
+Dynamic: license-file
+
+=============================
+Django Lineup
+=============================
+
+.. image:: https://badge.fury.io/py/django-lineup.svg
+    :target: https://badge.fury.io/py/django-lineup
+
+.. image:: https://travis-ci.org/otto-torino/django-lineup.svg?branch=master
+    :target: https://travis-ci.com/github/otto-torino/django-lineup
+
+.. image:: https://codecov.io/gh/otto-torino/django-lineup/branch/master/graph/badge.svg
+    :target: https://codecov.io/gh/otto-torino/django-lineup
+
+.. image:: https://static.pepy.tech/badge/django-lineup
+    :target: https://pepy.tech/project/django-lineup
+
+Multiple navigation system for django sites.
+
+Django Lineup lets you manage a tree of items. Each first level node represents a menu you can include in your templates.
+
+.. image:: images/lineup.png
+
+Documentation
+-------------
+
+The full documentation is at https://django-lineup.readthedocs.io.
+
+Quickstart
+----------
+
+Install Django Lineup::
+
+    pip install django-lineup
+
+``django-mptt`` is installed automatically as an internal dependency; it does
+not need to be added to your project's ``INSTALLED_APPS``.
+
+Add it to your `INSTALLED_APPS`:
+
+.. code-block:: python
+
+    INSTALLED_APPS = (
+        ...
+        'lineup.apps.LineupConfig',
+        ...
+    )
+
+Add to your main `urls.py`:
+
+.. code-block:: python
+
+    ...
+    path("lineup/", include("lineup.urls", namespace="lineup")),
+    ...
+
+Make sure the ``requests`` context processor is included (it is by default):
+
+.. code-block:: python
+
+    TEMPLATES = [
+      {
+        'OPTIONS': {
+          'context_processors': [
+            "django.template.context_processors.request",
+          ],
+        },
+      },
+    ]
+
+Render a menu:::
+
+    {% load lineup_tags %}
+    {% lineup_menu 'my-root-item-slug '%}
+
+Render the breadcrumbs:::
+
+    {% load lineup_tags %}
+    {% lineup_breadcrumbs 'my-root-item-slug '%}
+
+Import a menu from a json:::
+
+    $ python manage.py import_menu_from_json
+
+Json example:::
+
+    {
+      "label": "Main Menu",
+      "slug": "main-menu",
+      "order": 0,
+      "children": [
+        {
+          "label": "Tools",
+          "slug": "tools",
+          "order": 0,
+          "children": [
+            {
+              "label": "DNS Tools",
+              "slug": "dns-tools",
+              "order": 0,
+              "login_required": true,
+              "children": [
+                {
+                  "label": "DMARC DNS Tools",
+                  "slug": "dmarc-dns-tools",
+                  "link": "/dmarc-tools/",
+                  "title": "DMARC Rulez",
+                  "order": 0
+                }
+              ]
+            },
+            {
+              "label": "Password Generator",
+              "slug": "password-generator",
+              "order": 1
+            }
+          ]
+        },
+        {
+          "label": "Disabled Item",
+          "slug": "disabled-item",
+          "order": 1,
+          "enabled": false,
+          "children": [
+            {
+              "label": "Disabled child",
+              "slug": "disabled-child",
+              "order": 0
+            }
+          ]
+        },
+        {
+          "label": "Perm Item",
+          "slug": "perm-item",
+          "order": 2,
+          "permissions": [
+            "add_permission",
+            "view_session"
+          ]
+        }
+      ]
+    }
+
+Features
+--------
+
+- Multiple menus supported
+- Visibility logic: login required / permissions
+- Render menu tree templatetags
+- Breadcrumbs templetetag
+- Import a menu from json management command
+- Rebuild tree button in admin
+- `Django Baton <https://github.com/otto-torino/django-baton>`_ integration to highlight different menu in the admin
+
+Running Tests
+-------------
+
+Does the code actually work?
+
+::
+
+    source <YOURVIRTUALENV>/bin/activate
+    (myenv) $ pip install -r requirements_test.txt
+    (myenv) $ python runtests.py
+
+
+Development commands
+---------------------
+
+::
+
+    pip install -r requirements_dev.txt
+    invoke -l
+
+
+Example app
+---------------------
+
+This example is provided as a convenience feature to allow potential users to try the app straight from the app repo without having to create a django project.
+
+It can also be used to develop the app in place.
+
+To run this example, follow these instructions:
+
+1. Navigate to the root directory of your application (same as `manage.py`)
+2. Install the requirements for the package:
+
+		pip install -r requirements_test.txt
+
+3. Apply migrations
+
+		python manage.py migrate
+
+4. Run the server
+
+		python manage.py runserver
+
+5. Access from the browser at `http://127.0.0.1:8000`
+6. Admin user account is admin:admin
+
+
+Credits
+-------
+Django Lineup is developed by Otto SRL.
+
+Tools used in rendering this package:
+
+*  Cookiecutter_
+*  `cookiecutter-djangopackage`_
+
+.. _Cookiecutter: https://github.com/audreyr/cookiecutter
+.. _`cookiecutter-djangopackage`: https://github.com/pydanny/cookiecutter-djangopackage

django_lineup-1.0.1.dist-info/RECORD

@@ -0,0 +1,27 @@
+django_lineup-1.0.1.dist-info/licenses/LICENSE,sha256=xVzjK5SKF_i6osJ2PlbUGdoqJ2yBGNJgDPbrE0WlL8k,1071
+lineup/__init__.py,sha256=d4QHYmS_30j0hPN8NmNPnQ_Z0TphDRbu4MtQj9cT9e8,22
+lineup/admin.py,sha256=QoOCry9m1B9tkL0q-5fYfsltJgnMgwNtdO5PBvM1Hmw,2535
+lineup/apps.py,sha256=juHiBf84m8AWiC8T37VJTyQO2fHrFsOx6C3RzHbUGh4,374
+lineup/exceptions.py,sha256=2VkmNeSGC4OjBFrOxXRB1WLKNl2mLG2crXx9xO81rNk,141
+lineup/forms.py,sha256=N2q85OrPd1SZxzgf6slvE9HOBUIrASJ1yWj8AX2_9yg,340
+lineup/managers.py,sha256=TQSCpX6_SwHwO-coCXmp4X-nlP6qumfJ4Yo9AmacHsA,175
+lineup/models.py,sha256=OBFIjSnQs2cQs2JdwHEOwlo9OD3e109i7tydqBauY4E,4336
+lineup/urls.py,sha256=7LbwCS7JHGeMb6Vcm0bPow3-QjoCuIQD-kOce9f4j90,152
+lineup/views.py,sha256=QAqwdee-OFB4WyVXOLrXuc1Ipro6r5D7nEVo4gEd4m4,299
+lineup/management/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+lineup/management/commands/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+lineup/management/commands/import_menu_from_json.py,sha256=MB1LCLUZvS6HkrZWdslNrohlF2aw8EKYcVfFdcn4_hw,1024
+lineup/migrations/0001_initial.py,sha256=DxDz_OkmiYvazF_RFfhAqms5IkRccBBOFY8jHL3j1k4,2467
+lineup/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lineup/static/css/lineup.css,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lineup/static/js/lineup.js,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lineup/templates/admin/lineup/menuitem/change_list.html,sha256=b7GIvxJHGqVTzV9ha_HruO4l5aHTZvvA-mCHrYJ4h9A,499
+lineup/templates/lineup/base.html,sha256=zzaUPjEgvwxg-Gn2rZ6gIMWphucmEGvAU_skUXJIcDA,661
+lineup/templates/lineup/breadcrumbs.html,sha256=6iBTYAVeTCGWTrjULjPSD3OnviRePiHIGAl2a6nr8_c,327
+lineup/templates/lineup/menu.html,sha256=WLE9tsecTnE9SLgWLOjY9OwO_gpLbN38bx4bgU161Ts,887
+lineup/templatetags/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+lineup/templatetags/lineup_tags.py,sha256=RLd67gmQjzvyt0V3Sib1ATGBI2wb0VMKmy9bbeToLKA,5792
+django_lineup-1.0.1.dist-info/METADATA,sha256=atXff-NG11HsaB4-8-URirwvZIfWQuqN-HL0_fddwfs,6132
+django_lineup-1.0.1.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+django_lineup-1.0.1.dist-info/top_level.txt,sha256=6vFg2PzbsMrFEZHnUq1mv4jRZGnOFHc6Vf1pBfzxWm0,7
+django_lineup-1.0.1.dist-info/RECORD,,

django_lineup-1.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

django_lineup-1.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,14 @@
+
+MIT License
+
+Copyright (c) 2020, Otto SRL
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+
+

django_lineup-1.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+lineup

lineup/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.0.1"

lineup/admin.py

@@ -0,0 +1,69 @@
+# -*- coding: utf-8 -*-
+import sys
+import json
+from django.contrib import admin
+from django.utils.html import format_html
+from django.utils.translation import gettext_lazy as _
+
+from mptt.admin import MPTTModelAdmin
+
+from .models import MenuItem
+from .forms import MenuItemForm
+
+baton = 'baton' in sys.modules
+
+if baton:
+    from baton.admin import RelatedDropdownFilter
+
+
+class MenuItemInline(admin.StackedInline):
+    '''
+    Tabular Inline View for MenuItem
+    '''
+    model = MenuItem
+    form = MenuItemForm
+    extra = 1
+    classes = ('collapse-entry', 'expand-first', )
+    prepopulated_fields = {'slug': ('label',)}
+
+
+@admin.register(MenuItem)
+class MenuItemAdmin(MPTTModelAdmin):
+    form = MenuItemForm
+    change_list_template = "admin/lineup/menuitem/change_list.html"
+    list_display = ('indented_slug', 'label', 'parent', 'link', 'order', 'login_required', 'enabled', )
+    list_filter = (('parent', RelatedDropdownFilter, ) if baton else 'parent', 'enabled', 'login_required', )
+    list_editable = ('order', )
+    search_fields = ('label', )
+    filter_horizontal = ('permissions', )
+    inlines = [MenuItemInline, ]
+    prepopulated_fields = {'slug': ('label',)}
+    fieldsets = (
+        (_('Main'), {
+            'fields': ('parent', 'label', 'slug', 'link', 'title', 'order', 'extras' ),
+            'classes': ('baton-tabs-init', 'baton-tab-fs-permissions', 'baton-tab-inline-children', ),
+            'description': _('A menu item without parent identifies a new menu.')
+
+        }),
+        (_('Visibility'), {
+            'fields': ('enabled', 'login_required', 'permissions', ),
+            'classes': ('tab-fs-permissions', ),
+            'description': _('Yuo can decide to disable or restrict the visibility of this voice and consequently of all its children. Keep in mind that also if a child is publicly visible, but this voice requires a login, then the child will not be visible to not logged users. The same happens for permissions restrictions.')
+        }),
+    )
+
+    @admin.display(description=_('slug'), ordering='slug')
+    def indented_slug(self, obj):
+        return format_html(
+            '<span style="padding-left: {}px">{}</span>',
+            8 + getattr(self, 'mptt_level_indent', 10) * obj.level,
+            obj.slug,
+        )
+
+    def baton_cl_rows_attributes(self, request, cl):
+        data = {}
+        for item in MenuItem.objects.filter(parent__isnull=True):
+            data[item.id] = {
+                'class': 'table-info',
+            }
+        return json.dumps(data)

lineup/apps.py

@@ -0,0 +1,11 @@
+# -*- coding: utf-8
+from django.apps import AppConfig
+from django.utils.translation import gettext_lazy as _
+
+
+class LineupConfig(AppConfig):
+    # Keep the primary key type in sync with the historical migration even
+    # when the host project defaults to BigAutoField.
+    default_auto_field = 'django.db.models.AutoField'
+    name = 'lineup'
+    verbose_name = _('Menu')

lineup/exceptions.py

@@ -0,0 +1,10 @@
+class InvalidJson(Exception):
+    pass
+
+
+class UnsupportedJsonData(Exception):
+    pass
+
+
+class MissingJsonRequiredProp(Exception):
+    pass

lineup/forms.py

@@ -0,0 +1,10 @@
+from django import forms
+
+class MenuItemForm(forms.ModelForm):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        permissions = self.fields.get("permissions")
+        if permissions:
+            permissions.queryset = permissions.queryset.select_related(
+                "content_type"
+            )

lineup/management/__init__.py

@@ -0,0 +1 @@
+

lineup/management/commands/__init__.py

@@ -0,0 +1 @@
+

lineup/management/commands/import_menu_from_json.py

@@ -0,0 +1,35 @@
+# import the logging library
+import logging
+import os
+
+from django.core.management.base import BaseCommand, CommandError
+
+from lineup.models import MenuItem
+
+# Get an instance of a logger
+logger = logging.getLogger(__name__)
+
+
+class Command(BaseCommand):
+    help = 'Imports a menu tree from a json file'
+
+    def add_arguments(self, parser):
+        parser.add_argument('json_path', type=str)
+
+    def handle(self, *args, **options):
+        path = options['json_path']
+        if not os.path.isfile(path):
+            raise CommandError('File %s does not exist' % path)
+
+        # read file
+        with open(path, 'r') as json_file:
+            json_data = json_file.read()
+
+        if json_data:
+            try:
+                MenuItem.from_json(json_data)
+                self.stdout.write(self.style.SUCCESS('Successfully imported menu'))
+            except Exception as e:
+                raise CommandError('Cannot import menu: %s' % str(e))
+        else:
+            raise CommandError('File %s is empty' % path)

lineup/managers.py

@@ -0,0 +1,7 @@
+from mptt.managers import TreeManager
+
+
+class MenuItemManager(TreeManager):
+
+    def enabled(self, *args, **kwargs):
+        return self.filter(*args, enabled=True, **kwargs)

lineup/migrations/0001_initial.py

@@ -0,0 +1,41 @@
+# Generated by Django 4.2.23 on 2025-06-26 12:37
+
+from django.db import migrations, models
+import django.db.models.deletion
+import mptt.fields
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        ('auth', '0012_alter_user_first_name_max_length'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='MenuItem',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('label', models.CharField(help_text='Display name on the website.', max_length=50, verbose_name='label')),
+                ('slug', models.SlugField(help_text='Unique identifier for the menu voice.', unique=True, verbose_name='slug')),
+                ('link', models.CharField(blank=True, max_length=255, null=True, verbose_name='link')),
+                ('title', models.CharField(blank=True, max_length=255, null=True, verbose_name='title')),
+                ('order', models.IntegerField(verbose_name='order')),
+                ('enabled', models.BooleanField(default=True, verbose_name='enabled')),
+                ('login_required', models.BooleanField(default=False, help_text='If this is checked, only logged-in users will be able to view the item.', verbose_name='login required')),
+                ('extras', models.CharField(blank=True, help_text='Comma separated list of extra-attributes, e.g.: <code>icon="fa fa-user",data-tooltip="Go home!"</code>', max_length=255, null=True, verbose_name='extras')),
+                ('lft', models.PositiveIntegerField(editable=False)),
+                ('rght', models.PositiveIntegerField(editable=False)),
+                ('tree_id', models.PositiveIntegerField(db_index=True, editable=False)),
+                ('level', models.PositiveIntegerField(editable=False)),
+                ('parent', mptt.fields.TreeForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, related_name='children', to='lineup.menuitem', verbose_name='parent')),
+                ('permissions', models.ManyToManyField(blank=True, help_text='If empty, the menu item will be publicly visible, otherwise only users with at least one of the selected permissions could see it.', to='auth.permission', verbose_name='permissions')),
+            ],
+            options={
+                'verbose_name': 'Menu item',
+                'verbose_name_plural': 'Menu items',
+            },
+        ),
+    ]

lineup/models.py

@@ -0,0 +1,139 @@
+# -*- coding: utf-8 -*-
+import json
+import logging
+import re
+
+from django.contrib.auth.models import Permission
+from django.db import models
+from django.utils.translation import gettext_lazy as _
+from django.utils.safestring import mark_safe
+from django.db import transaction
+from django.db.models.signals import post_delete, post_save
+from django.dispatch import receiver
+from django.core.cache import cache
+
+from mptt.models import MPTTModel, TreeForeignKey
+
+from .managers import MenuItemManager
+from .exceptions import InvalidJson, UnsupportedJsonData, MissingJsonRequiredProp
+
+logger = logging.getLogger(__name__)
+
+
+class MenuItem(MPTTModel):
+    label = models.CharField(
+        _("label"), max_length=50, help_text=_("Display name on the website.")
+    )
+    slug = models.SlugField(
+        _("slug"), unique=True, help_text=_("Unique identifier for the menu voice.")
+    )
+    parent = TreeForeignKey(
+        "self",
+        verbose_name=_("parent"),
+        on_delete=models.CASCADE,
+        null=True,
+        blank=True,
+        related_name="children",
+    )
+    link = models.CharField(_("link"), max_length=255, blank=True, null=True)
+    title = models.CharField(_("title"), max_length=255, blank=True, null=True)
+    order = models.IntegerField(_("order"))
+    enabled = models.BooleanField(_("enabled"), default=True)
+    login_required = models.BooleanField(
+        _("login required"),
+        default=False,
+        help_text=_(
+            "If this is checked, only logged-in users will be able to view the item."
+        ),  # noqa
+    )
+    permissions = models.ManyToManyField(
+        Permission,
+        verbose_name=_("permissions"),
+        blank=True,
+        help_text=_(
+            "If empty, the menu item will be publicly visible, otherwise only users with at least one of the selected permissions could see it."  # noqa
+        ),
+    )
+    extras = models.CharField(
+        _("extras"),
+        max_length=255,
+        blank=True,
+        null=True,
+        help_text=mark_safe(_("Comma separated list of extra-attributes, e.g.: <code>icon=\"fa fa-user\",data-tooltip=\"Go home!\"</code>")),
+    )
+
+    objects = MenuItemManager()
+
+    active = False
+    with_active = False
+
+    def __str__(self):
+        return "{}".format(self.label)
+
+    class Meta:
+        verbose_name = _("Menu item")
+        verbose_name_plural = _("Menu items")
+
+    class MPTTMeta:
+        order_insertion_by = ("order",)
+
+    @classmethod
+    def from_json(cls, json_string):
+        try:
+            d = json.loads(json_string)
+        except Exception as e:
+            raise InvalidJson("Cannot parse provided json: %s" % str(e))
+
+        if not isinstance(d, dict):
+            raise UnsupportedJsonData(
+                "Provided json should be a dictionary containing a single root voice"
+            )
+
+        with transaction.atomic():
+            res = cls.create_item_from_dict(d)
+
+        return res
+
+    @classmethod
+    def create_item_from_dict(cls, d, parent=None):
+        if "label" not in d or "slug" not in d or "order" not in d:
+            raise MissingJsonRequiredProp(
+                "label, slug and order properties are mandatory"
+            )
+
+        item = MenuItem.objects.create(
+            parent=parent,
+            label=d.get("label"),
+            slug=d.get("slug"),
+            order=d.get("order"),
+            link=d.get("link", None),
+            title=d.get("title", None),
+            enabled=d.get("enabled", True),
+            login_required=d.get("login_required", False),
+            extras=d.get("extras", None),
+        )
+
+        for permission_code in d.get("permissions", []):
+            item.permissions.add(Permission.objects.get(codename=permission_code))
+
+        for child in d.get("children", []):
+            cls.create_item_from_dict(child, item)
+
+        return item
+
+    def is_active(self, path, prefix=""):
+        return self.link and self.link == path
+
+    def extras_dict(self):
+        try:
+            return dict(
+                [re.sub('"|\'', '', i).strip() for i in s.split("=")]
+                for s in self.extras.split(",")
+            )
+        except Exception:
+            return {}
+
+@receiver(post_save, sender=MenuItem)
+@receiver(post_delete, sender=MenuItem)
+def clear_lineup_cache(sender , **kwargs):
+    cache.delete("lineup")

lineup/templates/admin/lineup/menuitem/change_list.html

@@ -0,0 +1,13 @@
+{% extends "admin/change_list.html" %}
+{% load admin_list i18n %}
+
+{% block result_list %}
+    {% if action_form and actions_on_top and cl.show_admin_actions %}{% admin_actions %}{% endif %}
+    {% result_list cl %}
+    {% if action_form and actions_on_bottom and cl.show_admin_actions %}{% admin_actions %}{% endif %}
+{% endblock %}
+
+{% block object-tools-items %}
+    <li><a href="{% url 'lineup:rebuild' %}" class="rebuildlink">{% trans "Rebuild" %}</a></li>
+    {{ block.super }}
+{% endblock %}

lineup/templates/lineup/base.html

@@ -0,0 +1,21 @@
+
+{% comment %}
+As the developer of this package, don't place anything here if you can help it
+since this allows developers to have interoperability between your template
+structure and their own.
+
+Example: Developer melding the 2SoD pattern to fit inside with another pattern::
+
+    {% extends "base.html" %}
+    {% load static %}
+
+    <!-- Their site uses old school block layout -->
+    {% block extra_js %}
+
+        <!-- Your package using 2SoD block layout -->
+        {% block javascript %}
+            <script src="{% static 'js/ninja.js' %}" type="text/javascript"></script>
+        {% endblock javascript %}
+
+    {% endblock extra_js %}
+{% endcomment %}

lineup/templates/lineup/breadcrumbs.html

@@ -0,0 +1,7 @@
+{% spaceless %}
+{% if items|length %}
+    <div class="lineup-breadcrumbs">
+        {% for item in items  %}<a{% if item.link %} href="{{ item.link }}"{% endif %}{% if item.title %} title="{{ item.title }}"{% endif %}>{{ item }}</a>{% if not forloop.last %} › {% endif %}{% endfor %}
+    </div>
+{% endif %}
+{% endspaceless %}

lineup/templates/lineup/menu.html

@@ -0,0 +1,21 @@
+{% load lineup_tags %}
+{% spaceless %}
+{% comment %}
+    item is a dictionary:
+    - instance: MenuItem instance
+    - parent: the parent item
+    - children: list of child items
+    - active: whether the item is active or not
+    - has_active: whether the item contains an active item or not
+{% endcomment %}
+{% if items|length %}
+    <ul id="lineup-{{ slug }}" class="level-{{ level }}">
+        {% for item in items %}
+            <li class="{% if item.active %}active {% elif item.has_active %}has-active {% endif %}{% if item.children|length %}has-children {% endif %}">
+                <a{% if item.instance.link %} href="{{ item.instance.link }}"{% endif %}{% if item.instance.title %} title="{{ item.instance.title }}"{% endif %}>{{ item.instance.label }}</a>
+                {% lineup_menu item %}
+            </li>
+        {% endfor %}
+    </ul>
+{% endif %}
+{% endspaceless %}

lineup/templatetags/__init__.py

@@ -0,0 +1 @@
+

lineup/templatetags/lineup_tags.py

@@ -0,0 +1,170 @@
+# -*- coding: utf-8 -*-
+import logging
+from django.core.cache import cache
+
+from django import template
+from django.contrib.auth.models import Permission
+from django.db.models import Q, Count
+from django.urls import LocalePrefixPattern
+from django.utils.translation import get_language
+from ..models import MenuItem
+
+register = template.Library()
+logger = logging.getLogger(__name__)
+
+
+def get_all_user_permissions_id_list(user):
+    """
+    Returns a flat list of all user permissions ids
+    """
+    # individual permissions
+    perms = list(Permission.objects.filter(user=user).values_list("id", flat=True))
+    # permissions that the user has via a group
+    group_perms = list(
+        Permission.objects.filter(group__user=user).values_list("id", flat=True)
+    )
+    return perms + group_perms
+
+
+def set_active_voice(path, items):
+    """
+    Sets the active property to the active voice, and with_active to
+    all its parents
+    """
+    lang_code = get_language()
+    path_to_check = path
+
+    if lang_code:
+        prefix_to_remove = f"/{lang_code}"
+
+        if path.startswith(prefix_to_remove):
+            path_to_check = path.removeprefix(prefix_to_remove)
+            if not path_to_check.startswith('/'):
+                path_to_check = '/' + path_to_check
+
+    for item in items:
+        if item.get("instance").is_active(path_to_check):
+            item["active"] = True
+            parent = item.get("parent")
+            while parent is not None:
+                parent["has_active"] = True
+                parent = parent.get("parent")
+
+
+def create_tree(context, root, parent=None):
+    # get current user
+    user = context.get("user")
+
+    # if root is not enabled, do not show children
+    if not root.enabled:
+        return {}
+
+    # if root visibility restrictions and user is not authenticated do not show children
+    if not user.is_authenticated and (
+        root.login_required or root.permissions_count > 0
+    ):  # noqa
+        return {}
+
+    if not user.is_authenticated:
+        # unlogged user sees only public items
+        items = root.children.enabled(login_required=False, permissions=None).annotate(permissions_count=Count("permissions"))
+    elif user.is_superuser:
+        # superuser sees all enabled items
+        items = root.children.enabled().annotate(permissions_count=Count("permissions"))
+    else:
+        # logged in user which is not superuse should check for permissions
+        permissions = context.get("lineup_permissions", None)
+        if permissions is None:
+            permissions = get_all_user_permissions_id_list(user)
+            # put in context to avoid querying again at every iteration
+            context["lineup_permissions"] = permissions
+
+        items = root.children.enabled(
+            Q(permissions__id__in=permissions) | Q(permissions=None)
+        ).annotate(permissions_count=Count("permissions")).distinct()
+
+    # parent needed to traverse upward for has-active functionality
+    el = {"instance": root, "parent": parent}
+    el["children"] = [create_tree(context, child, el) for child in items]
+
+    # search active voice
+    if "request" in context:
+        path = context["request"].META["PATH_INFO"]
+        set_active_voice(path, el["children"])
+
+    return el
+
+
+@register.inclusion_tag("lineup/menu.html", takes_context=True)
+def lineup_menu(context, item):
+    """
+    Renders the whole tree if called recursively with different item param.
+    - If item is a slug, the whole tree dictionary is created. and the first
+    level items rendered.
+    - If item is a dict, it just continues traversing rendering its children.
+    """
+    if isinstance(item, str):
+        try:
+            # cache depends on user (permissions) and path (active item)
+            path = ""
+            user = context.get("user")
+            if "request" in context:
+                path = context["request"].META["PATH_INFO"]
+            t = cache.get_or_set("lineup", {}, None)
+            key = "%s:%s:%s" % (item, user.id, path)
+            if t.get(key, None) is None:
+                root = MenuItem.objects.prefetch_related("children", "permissions").annotate(permissions_count=Count("permissions")).get(slug=item)
+                tree = create_tree(context, root)
+                items = tree.get("children", [])
+                slug = item
+                level = root.level
+                t[key] = (items, slug, level)
+                cache.set("lineup", t, None)
+            else:
+                (items, slug, level) = t[key]
+        except MenuItem.DoesNotExist:
+            logger.error("Provided lineup menu slug %s not found" % item)
+            return context
+    elif isinstance(item, dict):
+        items = item.get("children")
+        slug = item.get("instance").slug
+        level = item.get("instance").level
+
+    else:
+        items = []
+        slug = None
+        level = None
+
+    context["items"] = items
+    context["slug"] = slug
+    context["level"] = level
+
+    return context
+
+
+@register.inclusion_tag("lineup/breadcrumbs.html", takes_context=True)
+def lineup_breadcrumbs(context, slug):
+    """
+    Renders menu breadcrumbs.
+    """
+    if "request" in context:
+        path = context["request"].META["PATH_INFO"]
+        active_items = MenuItem.objects.enabled(link=path)
+
+        found = False
+        items = []
+        for active_item in active_items:
+            items.append(active_item)
+            parent = active_item.parent
+            while parent is not None and parent.enabled:
+                items.insert(0, parent)
+                parent = parent.parent
+            if items.pop(0).slug == slug:
+                found = True
+                break
+
+        if found:
+            context["items"] = items
+        else:
+            context["items"] = []
+    return context

lineup/urls.py

@@ -0,0 +1,8 @@
+from django.urls import path
+
+from . import views
+
+app_name = "lineup"
+urlpatterns = [
+    path("", views.RebuildTreeView.as_view(), name="rebuild"),
+]

lineup/views.py

@@ -0,0 +1,9 @@
+from django.urls import reverse
+from django.views.generic import View
+from django.shortcuts import redirect
+from .models import MenuItem
+
+class RebuildTreeView(View):
+    def get(self, request):
+        MenuItem.objects.rebuild()
+        return redirect(reverse('admin:lineup_menuitem_changelist'))