Bases: Component

The DataGrid class is a component that generates a data grid for displaying data in a tabular format.

It automatically determines all regular model fields and shows their translated title. It also detects properties/getters instead of fields, the component tries to find out a proper name as title here by creating a capitalized version of the property name and translating it into the locale language. However, you have to provide a proper translation string for your property name in your .po file manually.

Note To keep Django's makemessages from commenting out these "unused" translations, just add an unused _("...") string anywhere into your method. E.g. when your property is named "display_name()", just add a _("Display name") anywhere into this method block. This keeps Django from garbage collecting this translation.

Example usage:

{% #datagrid object=request.user fields="first_name,last_name,email" %}

Bases: Component

A flexible component to display a Tabler.io list.

Bases: Component

HTML element that updates itself using HTMX when a certain Javascript event is triggerd anywhere in the body.

{% updateable id="my-card" trigger="person:changed" url=request.path %}

{% url 'person:update' as person_update_url %}
{% updateable elt="ul" id="people-list" trigger="person:changed" url=person_update_url %}

Bases: DynamicFormMixin

Mixin class for creating dynamic forms with HTMX.

This mixin extends the functionality of the DynamicFormMixin by adding htmx attributes to the form fields that can be used for triggering dynamic updates.

def clean(self):
    is_person = self.cleaned_data.get("is_person")

    if is_person:
        self.field_required(["first_name", "last_name"])
        self.field_required("title", "A title is definitely required here.")
        self.field_required(["age", "size"], "You forgot this field.")
    else:
        self.cleaned_data["first_name"] = ""
        self.cleaned_data["last_name"] = ""
        self.cleaned_data["title"] = ""

    return self.cleaned_data

A mixin that can be added to a Form during development/debugging, so that it logs all form errors.

A mixin class for Django forms that allows dynamic fields to be included or excluded based on certain conditions.

Bases: HxButton

A renderable action button from an IActionButton instance.

Render a HTMX enabled button.

{% hx_button url="person:add" method="post" icon="plus" dialog=True css_class="btn"

Render a hyperlink using HTMX.

Bases: HtmxResponseMixin

An interface Mixin that describes a component and can be rendered as plugin.

1. Declare an interface for HTMX components
2. Declare Implementations of that interface which also inherit from View.

Examples:

# in your plugin's api/interfaces.py, create an interface for your view
@Interface
class IUserProfileSection(IHtmxComponentMixin, ...):
    params = ["pk"]
    template_name = "common/layout/profile_section.html"
    ...

# in your plugin's views.py
def PasswordView(IUserProfileSection, UpdateView)
    ...
def OtherComponentView(IUserProfileSection, TemplateView)
    ...

Use them in your template:

{% for plugin in components.IUserProfileSection %}
    <a href="#"
       hx-get="{% url component.get_url_name user.id %}"
       hx-trigger="{% if component.selected %}load, {% endif %}click once"
       {# hx-push-url="{{ component.name }}" #}
       hx-target="#profile-content"
       class="list-group-item list-group-item-action d-flex align-items-center
        active">
        <i class="bi bi-{{ component.icon }} me-2"></i>
        {{ component.title }}
     </a>
{% endfor %}

You can also inherit from other mixins, e.g. PermissionRequiredMixin, etc.

class UserprofilePasswordSection(
    IUserProfileSection, PermissionRequiredMixin, TemplateView
):
    name = "password"
    permission_required = "..."
    template_name = "my_app/password_view.html

url_patterns = [
    path(...),
    path("profile/",
        include(
            (IUserProfileSectionView.get_url_patterns(), "profile"),
            namespace="profile"
        )
    ),
]

# or directly add the url_patterns to the main list:

url_patterns += IUserProfileSectionView.get_url_patterns()

Render an icon using Bootstrap 5.

A mixin that can be added to a View that uses HTMX components.

This can be used if e.g. a View has tabs, or variable parts of the page that are extended by a component. The URL is pushed automatically with the new component as configurable GET parameter, e.g.: example.com/persons/42?tab=account

class MyView(UseComponentMixin, DetailView):
    components = [PersonAccountTab]

Bases: HttpResponse

An HTTP response that has no content.

Used for HTMX requests that should not return anything, like delete requests. The returned status code is 204.

Bases: HttpResponseRedirect

A Http response that redirects a HTMX request to the location given in redirect_to

Bases: MenuItemInterfaceMixin

An action button that can be added to an e.g. table row.

Bases: MenuItemInterfaceMixin

An extendable and versatile MenuItem Interface

You can use that for creating menu items in a named menu:

class AddUserAction(IMenuItem)
    menu = "page_actions"
    title = _("Add user")
    url = reverse_lazy("user:delete")
    icon = "user-delete"

Represents a named menu during a request.

Usually it is used in Django templates by calling menus.<name> which then will return all MenuItems with a matching "menu" name attribute. Therefore, Menu will be instantiated by a context_processor, so that the menu variable in the template

<ul>
{% for item in menus.user %}
    <li><a href="{{item.url}}">{{ item.title }}</a></li>
{% endfor %}
</ul>

A mixin that provides common functionality for menu items or action buttons etc.

Filters out django messages and puts them in to the HX-Trigger header if current request is a HTMX request

Bases: SingletonModel

Represents the settings of the application.

This model is meant to be subclassed by your application. Please add application specific settings as needed to this model.

Bases: Model

Represents a generic page.

This class is an abstract base class that provides common fields and methods for all page subclasses.

Bases: Model

Singleton Django Model.

Allow only one instance of the model to be created. To get the instance of the model, use <YourModel>.get_instance().

Bases: Page

Represents a generic page with versioning.

This class is an abstract base class that provides common fields and methods for all page subclasses.

Bases: IntegerChoices

Action buttons type, and their weights.

Bases: UpdateTableMixin, Table

A table mixin that provides an "actions" column for row actions.

The table will update itself if a given event is triggered. Per default, the actions column is positioned at the end via Meta.sequence. However, if you use your own Meta.sequence, don't forget to add the "actions" column at the end.

A table mixin that that updates itself using HTMX when a javascript event is triggered.

Bases: PermissionRequiredMixin

View mixin that only allows access for anonymous users.

Bases: PermissionRequiredMixin

Automatically uses view/create/change/delete permissions for the given model.

It automatically generates the "_" permission of the given model as necessary permission for this view.

Bases: Enum

Enumeration of possible dialog levels.

Levels are used from Python's logging module

Bases: PrepopulateFormViewMixin

Mixin class for dynamic form views.

This mixin can be used with any FormView class to automatically prepopulate fields from GET parameters, and adds them to a "context" variable which is available within the form instance.

This view is intended to be used together with DynamicHtmxFormMixin for the form_class.

It creates a form_id (if not given) and passes it to the form. This is needed as HTMX target id.

Bases: LatestVersionMixin, DetailView

Generic privacy page view that displays the newest LicensePage.

Bases: LatestVersionMixin, DetailView

Generic privacy page view that displays the newest PrivacyPage.

Bases: HtmxFormMixin, DeleteView

Enhanced DeleteView that per default returns an empty HttpResponse.

TODO either use success_url, OR success_event.¶

Bases: HtmxResponseMixin

Mixin for a form view that uses HTMX.

Returns an "Hx-Trigger" attribute which triggers a Javascript event on the client.

View Mixin to add HTMX functionality.

optionally checks if request originates from an HTMX request.

If called from HTMX, this view renders template names with a "_htmx" suffix.

A mixin for views that require fetching the latest version of an object.

You can override the template in <your_app_name>/versioned_page.html.

Bases: PermissionRequiredMixin, ModalFormViewMixin, CreateView

Convenience CreateView (with permissions) that lives in a Modal.

It automatically generates the Modal title and sets the "create_" permission of the given model as necessary permission. Override as needed.

Bases: HtmxFormMixin

Mixin for FormViews that should live in a modal.

It relies on crispy-forms intensively, and already provides a form helper instance attribute you can use.

In many cases, you need no template, as this mixin provides a generic one with a customizable title. The form is generated using crispy-forms. If you want to customize if further, then, extend "conjunto/modal-form.html". This template uses a header with a title block, a body, and a footer block to override, for your modal dialog. In the footer, there is always a "Cancel" button, and as default, a "Save" button, which you can override using the "footer" block.

When the modal pops up, the focus is set to the first visible input element.

You can customize the content of the "Save" button by changing the button_content attribute to another string.

If the form is saved successfully, it returns an empty HttpResponse(204) and emits the event specified in success_event on the client, so that it can reload changed content.

Bases: _ModalModelViewMixin, UpdateView

Convenience UpdateView (with permissions) that lives in a Modal.

It automatically generates the Modal title and sets the "change_" permission of the given model as necessary permission. Override as needed.

A mixin class that prepopulates form fields with values from the request.GET parameters.

This mixin can be used with any FormView class to automatically prepopulate form fields with values from the URL query string parameters.

Example usage:

class MyFormView(PrepopulateFormMixin, FormView): form_class = MyForm template_name = 'my_template.html' success_url = reverse_lazy('my_success_url')

In the above example, the form fields will be prepopulated with values from the URL query string parameters when the form view is loaded.