search

otto-torino / django-baton

A cool, modern and responsive django admin application based on bootstrap 5 that brings AI to the Django admin - https://baton.sqrt64.it/
MIT License
876 stars 95 forks source link

readme

django-baton

Version Build status Documentation Status License Downloads

A cool, modern and responsive django admin application based on bootstrap 5, which brings AI in your admin panel.

Documentation: readthedocs

Live Demo

Now you can try django-baton using the new shining live demo! Login with user demo and password demo

https://django-baton.sqrt64.it/

Last changes

Baton 4.0.* introduces a bunch of new AI functionalities!

It also introduces themes, and makes it easier to customize the application, there is no need to recompile the js app unless you wanto to change primary and secondary colors or you need heavy customization.

Screenshot

Table of contents

Features

Supports Django >= 2.1. For older versions of Django, please use django-baton@1.13.2.

This application was written with one concept in mind: overwrite as few django templates as possible. Everything is styled through CSS and when required, JS is used.

Baton is based on the following frontend technologies:

Flexbox is used to accomplish responsiveness. jQuery is used for DOM manipulations.

All JS, fonts and CSS are compiled, and produce a single JS file which is included in the base_site template.

A custom menu is provided, the menu is rendered through JS, and data is fetched in JSON format through an AJAX request.

Installation

Install the last stable release

$ pip install django-baton

or clone the repo inside your project

$ git clone https://github.com/otto-torino/django-baton.git

Add baton and baton.autodiscover to your INSTALLED_APPS:

INSTALLED_APPS = (
    # ...
    'baton',
    'django.contrib.admin',
    # ... (place baton.autodiscover at the very end)
    'baton.autodiscover',
)

Run migrations

$ python manage.py migrate

Replace django.contrib.admin in your project urls, and add baton urls:

# from django.contrib import admin
from baton.autodiscover import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('baton/', include('baton.urls')),

]

Why two installed apps?

Well, first baton has to be placed before the django.contrib.admin app, because it overrides some templates and resets all CSS. The baton.autodiscover entry is needed as the last installed app in order to register all applications for the admin. I decided to create a custom AdminSite class, to allow the customization of some variables the Django way (site_header, index_title, ...). I think it's a good approach to customize these vars instead of overwriting the orignal templates. The problem is that when creating a custom AdminSite, you have to register all the apps manualy. I didn't like that so I wrote this autodiscover module which automatically registers all the apps registered with the Django's default AdminSite. For this to work, all the apps must be already registered so this app should be the last in INSTALLED_APPS.

Configuration

The configuration dictionary must be defined inside your settings:

from baton.ai import AIModels

BATON = {
    'SITE_HEADER': 'Baton',
    'SITE_TITLE': 'Baton',
    'INDEX_TITLE': 'Site administration',
    'SUPPORT_HREF': 'https://github.com/otto-torino/django-baton/issues',
    'COPYRIGHT': 'copyright © 2020 <a href="https://www.otto.to.it">Otto srl</a>', # noqa
    'POWERED_BY': '<a href="https://www.otto.to.it">Otto srl</a>',
    'CONFIRM_UNSAVED_CHANGES': True,
    'SHOW_MULTIPART_UPLOADING': True,
    'ENABLE_IMAGES_PREVIEW': True,
    'CHANGELIST_FILTERS_IN_MODAL': True,
    'CHANGELIST_FILTERS_ALWAYS_OPEN': False,
    'CHANGELIST_FILTERS_FORM': True,
    'CHANGEFORM_FIXED_SUBMIT_ROW': True,
    'MENU_ALWAYS_COLLAPSED': False,
    'MENU_TITLE': 'Menu',
    'MESSAGES_TOASTS': False,
    'GRAVATAR_DEFAULT_IMG': 'retro',
    'GRAVATAR_ENABLED': True,
    'LOGIN_SPLASH': '/static/core/img/login-splash.png',
    'FORCE_THEME': None,
    'SEARCH_FIELD': {
        'label': 'Search contents...',
        'url': '/search/',
    },
    'BATON_CLIENT_ID': 'xxxxxxxxxxxxxxxxxxxx',
    'BATON_CLIENT_SECRET': 'xxxxxxxxxxxxxxxxxx',
    'AI': {
        "MODELS": "myapp.foo.bar", # alternative to the below for lines, a function which returns the models dictionary
        "IMAGES_MODEL": AIModels.BATON_DALL_E_3,
        "SUMMARIZATIONS_MODEL": AIModels.BATON_GPT_4O_MINI,
        "TRANSLATIONS_MODEL": AIModels.BATON_GPT_4O,
        'ENABLE_TRANSLATIONS': True,
        'ENABLE_CORRECTIONS': True,
        'CORRECTION_SELECTORS': ["textarea", "input[type=text]:not(.vDateField):not([name=username]):not([name*=subject_location])"],
        "CORRECTIONS_MODEL": AIModels.BATON_GPT_3_5_TURBO,
    },
    'MENU': (
        { 'type': 'title', 'label': 'main', 'apps': ('auth', ) },
        {
            'type': 'app',
            'name': 'auth',
            'label': 'Authentication',
            'icon': 'fa fa-lock',
            'models': (
                {
                    'name': 'user',
                    'label': 'Users'
                },
                {
                    'name': 'group',
                    'label': 'Groups'
                },
            )
        },
        { 'type': 'title', 'label': 'Contents', 'apps': ('flatpages', ) },
        { 'type': 'model', 'label': 'Pages', 'name': 'flatpage', 'app': 'flatpages' },
        { 'type': 'free', 'label': 'Custom Link', 'url': 'http://www.google.it', 'perms': ('flatpages.add_flatpage', 'auth.change_user') },
        { 'type': 'free', 'label': 'My parent voice', 'default_open': True, 'children': [
            { 'type': 'model', 'label': 'A Model', 'name': 'mymodelname', 'app': 'myapp' },
            { 'type': 'free', 'label': 'Another custom link', 'url': 'http://www.google.it' },
        ] },
    )
}

AI, MENU and SEARCH_FIELD configurations in detail:

AI

Django Baton can provide you AI assistance in the admin interface: translations, summarizations, corrections and image generation. You can choose which model to use for each functionality, please note that different models have different prices, see Baton site.

Django Baton supports native fields (input, textarea) and ckeditor (django-ckeditor package) by default, but provides hooks you can use to add support to any other wysiwyg editor, read more in the AI section.

Available models

You can configure your preferred model for each functionality, you may choose between the following:

class AIModels:
    BATON_GPT_3_5_TURBO = "gpt-3.5-turbo" # translations, summarizations and corrections
    BATON_GPT_4_TURBO = 'gpt-4-turbo' # translations, summarizations and corrections
    BATON_GPT_4O = 'gpt-4o' # translations, summarizations and corrections
    BATON_GPT_4O_MINI = 'gpt-4o-mini' # translations, summarizations and corrections
    BATON_DALL_E_3 = 'dall-e-3' # images

We currently support just the dall-e-3 model for images generation.

You can set the models used with a simple configuration:

    'AI': {
        # ...
        "IMAGES_MODEL": AIModels.BATON_DALL_E_3,
        "SUMMARIZATIONS_MODEL": AIModels.BATON_GPT_4O_MINI,
        "TRANSLATIONS_MODEL": AIModels.BATON_GPT_4O,
        # ...
    },

Or you can set the path to the function which returns the models dictionary:

    # config
    'AI': {
        # ...
        "MODELS": "myapp.foo.bar",
        # ...
    },

    # myapp/foo.py
    from baton.ai import AIModels
    def bar():
        return {
            "IMAGES_MODEL": AIModels.BATON_DALL_E_3,
            "SUMMARIZATIONS_MODEL": AIModels.BATON_GPT_4O_MINI,
            "TRANSLATIONS_MODEL": AIModels.BATON_GPT_4O,
        }

If you don't set any of the models, the default models (BATON_GPT_4O_MINI and BATON_DALL_E_3) will be used.

Translations

Note: It may happen that the AI does not translate in the right language. Also it tries to preserve HTML but not always it works. Check the contents before submitting.

The translations feature is designed to work with the django-modeltranslation package.

If enabled, it will add a Translate button in every change form page. This button will trigger a request to the baton main site which will return all the translations needed in the page.
Baton will then fill in the fields with the translations.

Important! Translate many long texts at once can be slow, so be sure to increase the timeout threshold in your web server configuration! The translate request is performed to the django application which then calls the external translation service, so if you have a small timeout it may happen that the request to the external translation service goes on and you're charged for it but the application closes the request with a 502 error!

In order to use this feature, you need to set the BATON_CLIENT_ID and BATON_CLIENT_SECRET keys in the configuration dictionary. In order to obtain these keys you must create an account at Baton. Please visit the site for more information and pricing.

    ...
    'BATON_CLIENT_ID': 'xxxxxxxxxxxxxxxxxxxx',
    'BATON_CLIENT_SECRET': 'xxxxxxxxxxxxxxxxxx',
    'AI': {
        'ENABLE_TRANSLATIONS': True,
        'TRANSLATIONS_MODEL': AIModels.BATON_GPT_4O, # default AIModels.BATON_GPT_4O_MINI
    },
    ...

Corrections

You can also enable the AI corrections feature:

    ...
    'AI': {
        'ENABLE_CORRECTIONS': True,
        'CORRECTIONS_MODEL': AIModels.BATON_GPT_4O, # default AIModels.BATON_GPT_4O_MINI
        'CORRECTION_SELECTORS': ["textarea", "input[type=text]:not(.vDateField):not([name=username]):not([name*=subject_location])"],
    },
    ...

In this case near the labels of all fields which satisfy one provided selector, and all ckeditor fields, will appear an icon to trigger the AI correction. If the corrected text is the same as the original one, a check icon will appear near the field, otherwise a modal is open, showing the diff between the original and the corrected text. At that point you can decide to use the corrected text just by pressing the confirm button.

The default selectors are textarea and input[type=text]:not(.vDateField):not([name=username]):not([name*=subject_location]).

There is another way to trigger the correction in cases the label is not visible: ctrl + left mouse click on the field.

Corrections

Summarizations and image generations

These functionalities are described in detail in the AI section.

MENU

Currently four kind of items are supported: title, app, model and free.

Title and free voices can have children, which follow the following rules:

Items with children (title, app, free) can specify a default_open key to expand the submenu by default.

If you don't define a MENU key in the configuration dictionary, the default MENU is shown.

Title

Like MAIN and CONTENTS in the screenshot, it represents a menu section. You should set a label and optionally apps or perms key, used for visualization purposes.

If the title voice should act as a section title for a group of apps, you'd want to specify these apps, because if the user can't operate over them, then the voice is not shown. You can also define some perms (OR condition), like this:

{ 'type': 'title', 'label': 'main', 'perms': ('auth.add_user', ) },

Title items can have children and so you can specify the _defaultopen key.

App

You must specify the type and name keys. Optionally, an icon key (you can use FontAwesome classes which are included by default), a _defaultopen key and a models key. If you don't define the models key, the default app models are listed under your app.

NOTE: app name should be lowercase

Model

You must specify the type, name and app keys. Optionally, an icon key.

NOTE: model name should be lowercase

Free

You can specify free items. You must define a url and if you want some visibility permissions (OR clause). Free items can have children and so you can specify the _defaultopen key. Free items also accept a re property, which specifies a regular expression used to decide whether to highlight the voice or not (the regular expression is evaluated against the document location pathname).

{
    'type': 'free',
    'label': 'Categories',
    'url': '/admin/news/category/',
    're': '^/admin/news/category/(\d*)?'
}

SEARCH FIELD

With Baton you can optionally configure a search field in the sidebar above the menu.

Search field

With this functionality, you can configure a sidebar input search field with autocomplete functionality that can let you surf easily and quickly to any page you desire.

'SEARCH_FIELD': {
    'label': 'Label shown as placeholder',
    'url': '/api/path/',
},

The autocomplete field will call a custom api at every keyup event. Such api receives the text param in the querystring and should return a json response including the search results in the form:

{
    length: 2,
    data: [
        { label: 'My result #1', icon: 'fa fa-edit', url: '/admin/myapp/mymodel/1/change' },
        // ...
    ]
}

You should provide the results length and the data as an array of objects which must contain the label and url keys. The icon key is optional and is treated as css class given to an i element.

Let's see an example:

@staff_member_required
def admin_search(request):
    text = request.GET.get('text', None)
    res = []
    news = News.objects.all()
    if text:
        news = news.filter(title__icontains=text)
    for n in news:
        res.append({
            'label': str(n) + ' edit',
            'url': '/admin/news/news/%d/change' % n.id,
            'icon': 'fa fa-edit',
        })
    if text.lower() in 'Lucio Dalla Wikipedia'.lower():
        res.append({
            'label': 'Lucio Dalla Wikipedia',
            'url': 'https://www.google.com',
            'icon': 'fab fa-wikipedia-w'
        })
    return JsonResponse({
        'length': len(res),
        'data': res
    })

You can move between the results using the keyboard up and down arrows, and you can browse to the voice url pressing Enter.

Baton AI

Starting from 4.0.0, the new AI functionalities are available:

You can choose which AI model to use for each functionality, see AI configuration

Automatic Translations

In the configuration section you can specify if you want to enable the automatic translation with django-modeltranslation. If you enable it, the functionality will be activated sitewide. In every add/change form page which contains fields that need to be translated, the Translate button will appear in the object tools position.

Clicking it all the empty fields that need a translations will be filled with the translation fetched.

All default fields and CKEDITOR fields are supported, see AI Hooks section below if you need to support other wysiwyg editors.

Corrections

In the configuration section you can specify if you want to enable the corrections feature. If you enable it, the functionality will be activated sitewide. In every add/change form page which contains text fields (also CKEDITOR), an icon will appear near the label to trigger the AI correction. See AI Hooks section below if you need to support other wysiwyg editors.

When triggergin the correction there are two possible results:

Text Summarization

In your ModelAdmin classes you can define which fields can be summarized to create a content used to fill other model fields, look at the following example:

class MyModelAdmin(admin.ModelAdmin):
    # ...
    baton_summarize_fields = {
        "text_it": [{
            "target": "abstract_it",
            "words": 140,
            "useBulletedList": True,
            "language": "it",
        }, {
            "target": "meta_description_it",
            "words": 45,
            "useBulletedList": False,
        }],
    }

You have to specify the target field name. You can also optionally specify the follwing parameters:

The words and useBulletedList parameters can be edited int the UI when actually summarizing the text.

With this configuration, two (the number of targets) buttons will appear near the text_it field, each one opening a modal dialog with the configuration for the target field. In this modal you can edit the words and useBulletedList parameters and perform the summarization that will be inserted in the target field.

All default fields and CKEDITOR fields are supported, see AI Hooks section below if you need to support other wysiwyg editors.

Image Generation

Baton provides a new model field and a new image widget which can be used to generate images from text. The image field can be used as a normal image field, but also a new button will appear near it. The button will open a modal where you can set some options, describe the image you want and generate the image. You can then preview the image and if you like it you can save it in the file field with just one click.

from baton.fields import BatonAiImageField

class MyModel(models.Model):
    image = BatonAiImageField(verbose_name=_("immagine"), upload_to="news/")

There is also another way to add the AI image generation functionality to a normal ImageField if you do not want to use the BatonAiImageField model field:

<script>
    Baton.AI.addImageGeneration('{{ widget.name }}');
</script>

Stats widget

Baton provides a new widget which can be used to display stats about AI usage. Just include it in your admin index template:

{% load baton_tags %}

{% baton_ai_stats %}

Modal

AI Hooks

Baton AI functionalities do their job inspecting fields, retrieving and setting their values. WYSIWYG editors use javascript to sync with the native fields (like a textarea), and every editor behaves differently. Django Baton comes with support for django-ckeditor, but in the next future this will change because the package is almost deprecated.

Nevertheless, you can add your own hooks to support every other WYSIWYG editor you desire. When doing this you need to define the following functions, for example in your admin/base_site.html template:

    <!-- admin/base_site.html -->
    <script src="https://github.com/otto-torino/django-baton/raw/master/{% static 'baton/app/dist/baton.min.js' %}"></script>
    <script>
        (function () {
            // Get a list of fieldIds of all the editor managed fields, should return an array of ids
            Baton.AI.getEditorFieldsHook = function () {
              // i.e. for ckeditor
              return window.CKEDITOR ? Object.keys(window.CKEDITOR.instances) : []
            }

            // Given a field id return the field value and null or undefined if field id is not an editor field
            Baton.AI.getEditorFieldValueHook = function (fieldId) {
              // i.e. for ckeditor
              return window.CKEDITOR?.instances[fieldId]?.getData()
            }

            // Given a field id and a new value should set the editor field value if it exists and return true
            // should return false if the field is not an editor field
            Baton.AI.setEditorFieldValueHook = function (fieldId, value) {
              // i.e. for ckeditor
              if (window.CKEDITOR?.instances[fieldId]) {
                window.CKEDITOR.instances[fieldId].setData(value)
                return true
              }
              return false
            }

            // Given a field id should render the given checkmark icon to indicate the field is correct if it exists and return true,
            // should return false if the field is not an editor field
            Baton.AI.setEditorFieldCorrectHook = function (fieldId, icon) {
              // i.e. for ckeditor
              if (window.CKEDITOR?.instances[fieldId]) {
                $(`#${fieldId}`).parent('.django-ckeditor-widget').after(icon) // this uses jQuery
                return true
              }
              return false
            }
        })()
    </script>
    <script src="https://github.com/otto-torino/django-baton/raw/master/{% static 'baton/js_snippets/init_baton.js' %}"></script>

Page Detection

Baton triggers some of its functionalities basing upon the current page. For example, it will trigger the tab functionality only when the current page is an add form or change form page.

Baton understands which page is currently displayed performing some basic regular expressions against the location pathname. There may be cases in which you'd like to serve such contents at different and custom urls, in such cases you need a way to tell Baton which kind of page is tied to that url.

For this reason you can inject your custom hook, a javascript function which should return the page type and that receives as first argument the Baton's default function to use as fallback, i.e.

<!-- admin/base_site.html -->
{{ conf | json_script:"baton-config" }}
<script src="https://github.com/otto-torino/django-baton/raw/master/{% static 'baton/app/dist/baton.min.js' %}"></script>
<script>
    (function () {
        Baton.detectPageHook = fn => /newschange/.test(location.pathname) ? 'change_form' : fn()
    })()
</script>
<script src="https://github.com/otto-torino/django-baton/raw/master/{% static 'baton/js_snippets/init_baton.js' %}"></script>

In this case we tell Baton that when the location pathname includes the string newschange, then the page should be considered a change_form, otherwise we let Baton guess the page type.

So, in order to hook into the Baton page detection system, just define a Baton.detectPageHook function which receives the default function as first argument and should return the page type.

The available page types are the following: dashboard, admindocs, login, logout, passowrd_change, password_change_success, add_form, change_form, changelist, filer, default.

Signals

Baton provides a dispatcher that can be used to register function that will be called when some events occurr. Currently, Baton emits five types of events:

To use these, just override the baton admin/base_site.html template and register your listeners before calling Baton.init, i.e.

<!-- ... -->
<script>
    (function ($, undefined) {
        // init listeners
        Baton.Dispatcher.register('onReady', function () { console.log('BATON IS READY') })
        Baton.Dispatcher.register('onMenuReady', function () { console.log('BATON MENU IS READY') })
        Baton.Dispatcher.register('onNavbarReady', function () { console.log('BATON NAVBAR IS READY') })
        // end listeners
    })(jQuery, undefined)
</script>
<script src="https://github.com/otto-torino/django-baton/raw/master/{% static 'baton/js_snippets/init_baton.js' %}"></script>
<!-- ... -->

Js Utilities

Baton comes with a number of exported js modules you can use to enhance your admin application.

Dispatcher

Baton Dispatcher singleton module lets you subscribe to events and dispatch them, making use of the Mediator pattern.

Example:


// register a callback tied to the event
Baton.Dispatcher.register('myAppLoaded', function (evtName, s) { console.log('COOL ' + s) })

// emit the event
Baton.Dispatcher.emit('myAppLoaded', 'STUFF!')

Modal

Baton Modal class lets you insert some content on a bootstrap modal without dealing with all the markup.

Modal

Usage:

// modal configuration:
//
// let config = {
//     title: 'My modal title',
//     subtitle: 'My subtitle', // optional
//     content: '<p>my html content</p>', // alternative to url
//     url: '/my/url', // url used to perform an ajax request, the response is put inside the modal body. Alternative to content.
//     hideFooter: false, // optional
//     showBackBtn: false, // show a back button near the close icon, optional
//     backBtnCb: function () {}, // back button click callback (useful to have a multi step modal), optional
//     actionBtnLabel: 'save', // action button label, default 'save', optional
//     actionBtnCb: null, // action button callback, optional
//     onUrlLoaded: function () {}, // callback called when the ajax request has completed, optional
//     size: 'lg', // modal size: sm, md, lg, xl, optional
//     onClose: function () {} // callback called when the modal is closed, optional
// }
//
// constructs a new modal instance
// let myModal = new Baton.Modal(config)

let myModal = new Baton.Modal({
    title: 'My modal title',
    content: '<p>my html content</p>',
    size: 'lg'
})

myModal.open();
myModal.close();

myModal.update({
    title: 'Step 2',
    content: '<p>cool</p>'
})
myModal.toggle();

Js Translations

There are some circustamces in which Baton will print to screen some js message. Baton detects the user locale and will localize such messages, but it comes with just en and it translations provided.

Baton retrieves the current user locale from the lang attribute of the html tag.

However you can provide or add your own translations by attaching an object to the Baton namespace:

// these are the default translations, you can just edit the one you need, or add some locales. Baton engine will always
// pick up your custom translation first, if it finds them.
// you can define the object before Baton.init in the base_site template
Baton.translations = {
  unsavedChangesAlert: 'You have some unsaved changes.',
  uploading: 'Uploading...',
  filter: 'Filter',
  close: 'Close',
  save: 'Save',
  search: 'Search',
  cannotCopyToClipboardMessage: 'Cannot copy to clipboard, please do it manually: Ctrl+C, Enter',
  retrieveDataError: 'There was an error retrieving the data',
  lightTheme: 'Light theme',
  darkTheme: 'Dark theme'
}

If Baton can't find the translations for the user locale, it will default to en. Keep in mind that Baton will use en translations for all en-xx locales, but of course you can specify your custom translations!

List Filters

List Filters

Input Text Filters

Taken from this medium article

Baton defines a custom InputFilter class that you can use to create text input filters and use them as any other list_filters, for example:


# your app admin

from baton.admin import InputFilter

class IdFilter(InputFilter):
    parameter_name = 'id'
    title = 'id'

    def queryset(self, request, queryset):
        if self.value() is not None:
            search_term = self.value()
            return queryset.filter(
                id=search_term
            )

class MyModelAdmin(admin.ModelAdmin):
    list_filters = (
        'my_field',
        IdFilter,
        'my_other_field',
    )

Dropdown Filters

Taken from the github app django-admin-list-filter-dropdown

Baton provides a dropdown form of the following list filters:

Django admin filter name Baton name
SimpleListFilter SimpleDropdownFilter
AllValuesFieldListFilter DropdownFilter
ChoicesFieldListFilter ChoicesDropdownFilter
RelatedFieldListFilter RelatedDropdownFilter
RelatedOnlyFieldListFilter RelatedOnlyDropdownFilter

The dropdown is visible only if the filter contains at least three options, otherwise the default template is used.

Usage:

from baton.admin import DropdownFilter, RelatedDropdownFilter, ChoicesDropdownFilter

class MyModelAdmin(admin.ModelAdmin):
    # ...
    list_filter = (
        # for ordinary fields
        ('a_charfield', DropdownFilter),
        # for choice fields
        ('a_choicefield', ChoiceDropdownFilter),
        # for related fields
        ('a_foreignkey_field', RelatedDropdownFilter),
    )

Multiple choice Filters

Baton defines a custom MultipleChoiceListFilter class that you can use to filter on multiple options, for example:

# your app admin

from baton.admin import MultipleChoiceListFilter

class StatusListFilter(MultipleChoiceListFilter):
    title = 'Status'
    parameter_name = 'status__in'

    def lookups(self, request, model_admin):
        return News.Status.choices

class MyModelAdmin(admin.ModelAdmin):
    list_filters = (
        'my_field',
        StatusListFilter,
        'my_other_field',
    )

Changelist Includes

In order for this feature to work, the user browser must support html template tags.

Baton lets you include templates directly inside the change list page, in any position you desire. It's as simple as specifying the template path and the position of the template:

@admin.register(News)
class NewsAdmin(admin.ModelAdmin):
    #...
    baton_cl_includes = [
        ('news/admin_include_top.html', 'top', ),
        ('news/admin_include_below.html', 'below', )
    ]

In this case, Baton will place the content of the admin_include_top.html template at the top of the changelist section (above the search field), and the content of the admin_include_below.html below the changelist form.

Baton changelist includes

You can specify the following positions:

Position Description
top the template is placed inside the changelist form, at the top
bottom the template is placed inside the changelist form, at the bottom
above the template is placed above the changelist form
below the template is placed below the changelist form

And, of course, you can access the all the changelist view context variables inside your template.

Changelist Filters Includes

In order for this feature to work, the user browser must support html template tags.

Baton lets you include templates directly inside the change list filter container, at the top or the bottom. It's as simple as specifying the template path and the position of the template:

@admin.register(News)
class NewsAdmin(admin.ModelAdmin):
    #...
    baton_cl_filters_includes = [
        ('news/admin_filters_include_top.html', 'top', ),
        ('news/admin_filters_include_bottom.html', 'bottom', )
    ]

Baton changelist filters includes

You can specify the following positions:

Position Description
top the template is placed inside the changelist filter container, at the top
bottom the template is placed inside the changelist filter container, at the bottom

And, of course, you can access the all the changelist view context variables inside your template.

Changelist Row Attributes

In order for this feature to work, the user browser must support html template tags.

With Baton you can add every kind of html attribute (including css classes) to any element in the changelist table (cell, rows, ...)

Baton changelist row attributes

It's a bit tricky, let's see how:

  1. Add a baton_cl_rows_attributes function to your ModelAdmin class, which takes request and cl (changelist view) as parameters.
  2. Return a json dictionary where the keys are used to match an element and the values specifies the attributes and other rules to select the element.

Better to see an example:

class NewsModelAdmin(admin.ModelAdmin):
    # ...

    def get_category(self, instance):
        return mark_safe('<span class="span-category-id-%d">%s</span>' % (instance.id, str(instance.category)))
    get_category.short_description = 'category'

    def baton_cl_rows_attributes(self, request, cl):
        data = {}
        for news in cl.queryset.filter(category__id=2):
            data[news.id] = {
                'class': 'table-info',
            }
        data[news.id] = {
            'class': 'table-success',
            'data-lol': 'lol',
            'title': 'A fantasctic tooltip!',
            'selector': '.span-category-id-%d' % 1,
            'getParent': 'td',
        }
        return json.dumps(data)

In such case we're returning a dictionary with possibly many keys (each key is an id of a news instance).

The first kind of dictionary elements will add a table-info class to the tr (rows) containing the news respecting the rule category__id=2

The second kind of element instead uses some more options to customize the element selection: you can specify a css selector, and you can specify if Baton should then take one of its parents, and in such case you can give a parent selector also. In the example provided Baton will add the class table-success, data-attribute and the title attribute to the cell which contains the element .span-category-id-1.

So these are the rules:

Form tabs

Tabs

How much I loved django-suit form tabs? Too much. So, this was a feature I couldn't live without.

There are three types of tabs:

Tabs' titles are retrieved automatically. For fieldset and inline tabs, it's the fieldset's title and the inline related verbose name plural. For group tabs the first title is taken (either of an inline or fieldset section).

Using group tabs you can mix inlines with fields just by splitting fields into fieldsets and arranging them in your preferred order.

Let's see how to define tabs in your admin forms (everything is done through js, no templatetags or templates overriden):

class AttributeInline(admin.StackedInline):
    model = Attribute
    extra = 1

class FeatureInline(admin.StackedInline):
    model = Feature
    extra = 1

class ItemAdmin(admin.ModelAdmin):
    list_display = ('label', 'description', 'main_feature', )
    inlines = [AttributeInline, FeatureInline, ]

    fieldsets = (
        ('Main', {
            'fields': ('label', ),
            'classes': ('order-0', 'baton-tabs-init', 'baton-tab-inline-attribute', 'baton-tab-fs-content', 'baton-tab-group-fs-tech--inline-feature', ),
            'description': 'This is a description text'

        }),
        ('Content', {
            'fields': ('text', ),
            'classes': ('tab-fs-content', ),
            'description': 'This is another description text'

        }),
        ('Tech', {
            'fields': ('main_feature', ),
            'classes': ('tab-fs-tech', ),
            'description': 'This is another description text'

        }),
    )

As you can see these are the rules:

Other features:

Form Includes

In order for this feature to work, the user browser must support html template tags.

Baton lets you include templates directly inside the change form page near a field, in any position you desire. It's as simple as specifying the template path, the field name used as anchor and the position of the template:

@admin.register(News)
class NewsAdmin(admin.ModelAdmin):
    #...
    baton_form_includes = [
        ('news/admin_datetime_include.html', 'datetime', 'top', ),
        ('news/admin_content_include.html', 'content', 'above', )
    ]

In this case, Baton will place the content of the admin_datetime_include.html template at the top of the datetime field row, and the content of the admin_content_include.html above the content field row.

Baton form includes

You can specify the following positions:

Position Description
top the template is placed inside the form row, at the top
bottom the template is placed inside the form row, at the bottom
above the template is placed above the form row
below the template is placed below the form row
right the template is placed inline at the input field right side

And, of course, you can access the {{ original }} object variable inside your template.

It works seamlessly with the tab facility, if you include content related to a field inside one tab, then the content will be placed in the same tab.

Baton lets also include templates in the object tools top bar in the change form page, keep in mind that suche templates are injected inside an ul tag. The template can be inserted on the left or the right:

@admin.register(News)
class NewsAdmin(admin.ModelAdmin):
    #...
    baton_form_object_tools_include = ('news/object_tools_include.html', 'left', )

Baton form object tools includes

Collapsable stacked inlines entries

Screenshot

Baton lets you collapse single stacked inline entries, just add a collapse-entry class to the inline, with or without the entire collapse class:

class VideosInline(admin.StackedInline):
    model = Video
    extra = 1
    classes = ('collapse-entry', )  # or ('collapse', 'collapse-entry', )

And if you want the first entry to be initially expanded, add also the expand-first class:

class VideosInline(admin.StackedInline):
    model = Video
    extra = 1
    classes = ('collapse-entry', 'expand-first', )

Themes & Customization

It's easy to customize the appeareance of baton. You can override all the css variables, just create a baton/css/root.css file (see here) and serve it from an app listed before baton in INSTALLED_APPS.

You can also create themes directly from the admin site, just surf to /admin/baton/batontheme/. There can be only one active theme, if present, the saved content is used instead of the root.css file. So just copy the content of that file in the field and change the colors you want. Be aware that the theme content is considered safe and injected into the page as is, so be carefull.

If you need heavy customization or you need to customize the primary and secondary colors, you can edit and recompile the JS app which resides in baton/static/baton/app.

Customization

Make the changes you want, re-compile, get the compiled JS file, place it in the static folder of your main app, and place your main app (ROOTAPP) before baton in the INSTALLED_APPS.

So:

$ git clone https://github.com/otto-torino/django-baton.git
$ cd django-baton/baton/static/baton/app/
$ npm install
$ vim src/styles/_variables.scss
$ npm run compile
$ cp dist/baton.min.js ROOTAPP/static/baton/app/dist/

If you want to test your live changes, just start the webpack dev server:

$ cd django-baton/baton/static/baton/app/
$ npm run dev

And inside the base_site.html template, make these changes:

<!-- <script src="https://github.com/otto-torino/django-baton/raw/master/{% static 'baton/app/dist/baton.min.js' %}"></script> comment the compiled src and uncomment the webpack served src -->
<script src="http://localhost:8080/static/baton/app/dist/baton.min.js"></script>

Now while you make your changes to the JS app (CSS included), webpack will update the bundle automatically, so just refresh the page and you'll see your changes.

Tests

Starting from the release 1.7.1, django baton is provided with a set of unit and e2e tests. Testing baton is not so easy, because it almost do all the stuff with css rules and by manipulating the DOM. So the e2e tests are performed using selenium and inspecting the test application inside a real browser. In order to have them run properly, you need to have the test application running on localhost:8000.

Development

Start the test app (login admin:admin):

$ cd testapp
$ python3 -m venv .virtualenv
$ cd app
$ pip install -r requirements.txt
$ python manage.py runserver

Switch the baton js path in base_site.html

<!-- <script src="https://github.com/otto-torino/django-baton/raw/master/{% static 'baton/app/dist/baton.min.js' %}"></script> comment the compiled src and uncomment the webpack served src -->
<script src="http://localhost:8080/static/baton/app/dist/baton.min.js"></script>

Start the js app in watch mode

$ cd baton/static/baton/app
$ npm install
$ npm run dev

Now you'll see live all your changes in the testapp.

Commands

Install invoke and sphinx_rtd_theme

$ pip install invoke sphinx_rtd_theme

Now you can generate the documentation in order to check it. Inside the root dir:

$ invoke docs

Contributing

Read CONTRIBUTING.md

Star History

Star History Chart

Screenshots

Screenshot

Screenshot

Screenshot

Screenshot

Screenshot

Screenshot

Screenshot

Screenshot

Screenshot

Screenshot