Source code for crispy_forms.bootstrap

from random import randint

from django.template import Template
from django.template.loader import render_to_string
from django.utils.text import slugify

from .layout import Div, Field, LayoutObject, TemplateNameMixin
from .utils import TEMPLATE_PACK, flatatt, render_field


[docs]class PrependedAppendedText(Field): """ Layout object for rendering a field with prepended and appended text. Attributes ---------- template : str The default template which this Layout Object will be rendered with. attrs : dict Attributes to be applied to the field. These are converted into html attributes. e.g. ``data_id: 'test'`` in the attrs dict will become ``data-id='test'`` on the field's ``<input>``. Parameters ---------- field : str The name of the field to be rendered. prepended_text : str, optional The prepended text, can be HTML like, by default None appended_text : str, optional The appended text, can be HTML like, by default None input_size : str, optional For Bootstrap4+ additional classes to customise the input-group size e.g. ``input-group-sm``. By default None active : bool For Bootstrap3, a boolean to render the text active. By default ``False``. css_class : str, optional CSS classes to be applied to the field. These are added to any classes included in the ``attrs`` dict. By default ``None``. wrapper_class: str, optional CSS classes to be used when rendering the Field. This class is usually applied to the ``<div>`` which wraps the Field's ``<label>`` and ``<input>`` tags. By default ``None``. template : str, optional Overrides the default template, if provided. By default ``None``. **kwargs : dict, optional Additional attributes are converted into key="value", pairs. These attributes are added to the ``<div>``. Examples -------- Example:: PrependedAppendedText('amount', '$', '.00') """ template = "%s/layout/prepended_appended_text.html" def __init__( self, field, prepended_text=None, appended_text=None, input_size=None, *, active=False, css_class=None, wrapper_class=None, template=None, **kwargs, ): self.field = field self.appended_text = appended_text self.prepended_text = prepended_text self.active = active self.input_size = input_size if css_class: # Bootstrap 3 if "input-lg" in css_class: self.input_size = "input-lg" if "input-sm" in css_class: self.input_size = "input-sm" super().__init__(field, css_class=css_class, wrapper_class=wrapper_class, template=template, **kwargs) def render(self, form, context, template_pack=TEMPLATE_PACK, extra_context=None, **kwargs): extra_context = extra_context.copy() if extra_context is not None else {} extra_context.update( { "crispy_appended_text": self.appended_text, "crispy_prepended_text": self.prepended_text, "input_size": self.input_size, "active": getattr(self, "active", False), "wrapper_class": self.wrapper_class, } ) template = self.get_template_name(template_pack) return render_field( self.field, form, context, template=template, attrs=self.attrs, template_pack=template_pack, extra_context=extra_context, **kwargs, )
[docs]class AppendedText(PrependedAppendedText): """ Layout object for rendering a field with appended text. Attributes ---------- template : str The default template which this Layout Object will be rendered with. attrs : dict Attributes to be applied to the field. These are converted into html attributes. e.g. ``data_id: 'test'`` in the attrs dict will become ``data-id='test'`` on the field's ``<input>``. Parameters ---------- field : str The name of the field to be rendered. text : str, optional The appended text, can be HTML like, by default None input_size : str, optional For Bootstrap4+ additional classes to customise the input-group size e.g. ``input-group-sm``. By default None active : bool For Bootstrap3, a boolean to render the text active. By default ``False``. css_class : str, optional CSS classes to be applied to the field. These are added to any classes included in the ``attrs`` dict. By default ``None``. wrapper_class: str, optional CSS classes to be used when rendering the Field. This class is usually applied to the ``<div>`` which wraps the Field's ``<label>`` and ``<input>`` tags. By default ``None``. template : str, optional Overrides the default template, if provided. By default ``None``. **kwargs : dict, optional Additional attributes are converted into key="value", pairs. These attributes are added to the ``<div>``. Examples -------- Example:: AppendedText('amount', '.00') """ def __init__( self, field, text, *, input_size=None, active=False, css_class=None, wrapper_class=None, template=None, **kwargs, ): self.text = text super().__init__( field, appended_text=text, input_size=input_size, active=active, css_class=css_class, wrapper_class=wrapper_class, template=template, **kwargs, )
[docs]class PrependedText(PrependedAppendedText): """ Layout object for rendering a field with prepended text. Attributes ---------- template : str The default template which this Layout Object will be rendered with. attrs : dict Attributes to be applied to the field. These are converted into html attributes. e.g. ``data_id: 'test'`` in the attrs dict will become ``data-id='test'`` on the field's ``<input>``. Parameters ---------- field : str The name of the field to be rendered. text : str, optional The prepended text, can be HTML like, by default None input_size : str, optional For Bootstrap4+ additional classes to customise the input-group size e.g. ``input-group-sm``. By default None active : bool For Bootstrap3, a boolean to render the text active. By default ``False``. css_class : str, optional CSS classes to be applied to the field. These are added to any classes included in the ``attrs`` dict. By default ``None``. wrapper_class: str, optional CSS classes to be used when rendering the Field. This class is usually applied to the ``<div>`` which wraps the Field's ``<label>`` and ``<input>`` tags. By default ``None``. template : str, optional Overrides the default template, if provided. By default ``None``. **kwargs : dict, optional Additional attributes are converted into key="value", pairs. These attributes are added to the ``<div>``. Examples -------- Example:: PrependedText('amount', '$') """ def __init__( self, field, text, *, input_size=None, active=False, css_class=None, wrapper_class=None, template=None, **kwargs, ): self.text = text super().__init__( field, prepended_text=text, input_size=input_size, active=active, css_class=css_class, wrapper_class=wrapper_class, template=template, **kwargs, )
[docs]class FormActions(LayoutObject): """ Bootstrap layout object. It wraps fields in a <div class="form-actions"> Attributes ---------- template: str The default template which this Layout Object will be rendered with. Parameters ---------- *fields : HTML or BaseInput The layout objects to render within the ``ButtonHolder``. It should only hold `HTML` and `BaseInput` inherited objects. css_id : str, optional A custom DOM id for the layout object which will be added to the ``<div>`` if provided. By default None. css_class : str, optional Additional CSS classes to be applied to the ``<div>``. By default None. template : str, optional Overrides the default template, if provided. By default None. **kwargs : dict, optional Additional attributes are passed to ``flatatt`` and converted into key="value", pairs. These attributes are added to the ``<div>``. Examples -------- An example using ``FormActions`` in your layout:: FormActions( HTML(<span style="display: hidden;">Information Saved</span>), Submit('Save', 'Save', css_class='btn-primary') ) """ template = "%s/layout/formactions.html" def __init__(self, *fields, css_id=None, css_class=None, template=None, **kwargs): self.fields = list(fields) self.id = css_id self.css_class = css_class self.template = template or self.template self.flat_attrs = flatatt(kwargs) def render(self, form, context, template_pack=TEMPLATE_PACK, **kwargs): html = self.get_rendered_fields(form, context, template_pack, **kwargs) template = self.get_template_name(template_pack) context.update({"formactions": self, "fields_output": html}) return render_to_string(template, context.flatten())
[docs]class InlineCheckboxes(Field): """ Layout object for rendering checkboxes inline. Attributes ---------- template : str The default template which this Layout Object will be rendered with. attrs : dict Attributes to be applied to the field. These are converted into html attributes. e.g. ``data_id: 'test'`` in the attrs dict will become ``data-id='test'`` on the field's ``<input>``. Parameters ---------- *fields : str Usually a single field, but can be any number of fields, to be rendered with the same attributes applied. css_class : str, optional CSS classes to be applied to the field. These are added to any classes included in the ``attrs`` dict. By default ``None``. wrapper_class: str, optional CSS classes to be used when rendering the Field. This class is usually applied to the ``<div>`` which wraps the Field's ``<label>`` and ``<input>`` tags. By default ``None``. template : str, optional Overrides the default template, if provided. By default ``None``. **kwargs : dict, optional Additional attributes are converted into key="value", pairs. These attributes are added to the ``<div>``. Examples -------- Example:: InlineCheckboxes('field_name') """ template = "%s/layout/checkboxselectmultiple_inline.html" def render(self, form, context, template_pack=TEMPLATE_PACK, **kwargs): return super().render(form, context, template_pack=template_pack, extra_context={"inline_class": "inline"})
[docs]class InlineRadios(Field): """ Layout object for rendering radiobuttons inline. Attributes ---------- template : str The default template which this Layout Object will be rendered with. attrs : dict Attributes to be applied to the field. These are converted into html attributes. e.g. ``data_id: 'test'`` in the attrs dict will become ``data-id='test'`` on the field's ``<input>``. Parameters ---------- *fields : str Usually a single field, but can be any number of fields, to be rendered with the same attributes applied. css_class : str, optional CSS classes to be applied to the field. These are added to any classes included in the ``attrs`` dict. By default ``None``. wrapper_class: str, optional CSS classes to be used when rendering the Field. This class is usually applied to the ``<div>`` which wraps the Field's ``<label>`` and ``<input>`` tags. By default ``None``. template : str, optional Overrides the default template, if provided. By default ``None``. **kwargs : dict, optional Additional attributes are converted into key="value", pairs. These attributes are added to the ``<div>``. Examples -------- Example:: InlineRadios('field_name') """ template = "%s/layout/radioselect_inline.html" def render(self, form, context, template_pack=TEMPLATE_PACK, **kwargs): return super().render(form, context, template_pack=template_pack, extra_context={"inline_class": "inline"})
[docs]class FieldWithButtons(Div): """ A layout object for rendering a single field with any number of buttons. Attributes ---------- template : str The default template which this Layout Object will be rendered with. css_class : str, optional CSS classes to be applied to the wrapping ``<div>``. By default None. Parameters ---------- *fields : str or LayoutObject The first positional argument is the field. This can be either the name of the field as a string or an instance of `Field`. Following arguments will be rendered as buttons. input_size : str Additional CSS class to change the size of the input. e.g. "input-group-sm". css_id : str, optional A DOM id for the layout object which will be added to the wrapping ``<div>`` if provided. By default None. css_class : str, optional Additional CSS classes to be applied in addition to those declared by the class itself. By default None. template : str, optional Overrides the default template, if provided. By default None. **kwargs : dict, optional Additional attributes are passed to ``flatatt`` and converted into key="value", pairs. These attributes are added to the wrapping ``<div>``. Examples -------- Example:: FieldWithButtons( Field("password1", css_class="span4"), StrictButton("Go!", css_id="go-button"), input_size="input-group-sm", ) """ template = "%s/layout/field_with_buttons.html" field_template = "%s/field.html" def __init__(self, *fields, input_size=None, css_id=None, css_class=None, template=None, **kwargs): self.input_size = input_size super().__init__(*fields, css_id=css_id, css_class=css_class, template=template, **kwargs) def render(self, form, context, template_pack=TEMPLATE_PACK, extra_context=None, **kwargs): # We first render the buttons field_template = self.field_template % template_pack buttons = "".join( render_field( field, form, context, field_template, layout_object=self, template_pack=template_pack, **kwargs, ) for field in self.fields[1:] ) extra_context = {"div": self, "buttons": buttons} template = self.get_template_name(template_pack) if isinstance(self.fields[0], Field): # FieldWithButtons(Field('field_name'), StrictButton("go")) # We render the field passing its name and attributes return render_field( self.fields[0][0], form, context, template, attrs=self.fields[0].attrs, template_pack=template_pack, extra_context=extra_context, **kwargs, ) else: return render_field(self.fields[0], form, context, template, extra_context=extra_context, **kwargs)
[docs]class StrictButton(TemplateNameMixin): """ Layout object for rendering an HTML button in a ``<button>`` tag. Attributes ---------- template: str The default template which this Layout Object will be rendered with. field_classes : str The CSS classes to be applied to the button. By defult "btn". Parameters ---------- content : str The content of the button. This content is context aware, to bring this to life see the examples section. css_id : str, optional A custom DOM id for the layout object which will be added to the ``<button>`` if provided. By default None. css_class : str, optional Additional CSS classes to be applied to the ``<button>``. By default None. template : str, optional Overrides the default template, if provided. By default None. **kwargs : dict, optional Additional attributes are passed to `flatatt` and converted into key="value", pairs. These attributes are added to the ``<button>``. Examples -------- In your ``Layout``:: StrictButton("button content", css_class="extra") The content of the button is context aware, so you can do things like:: StrictButton("Button for {{ user.username }}") """ template = "%s/layout/button.html" field_classes = "btn" def __init__(self, content, css_id=None, css_class=None, template=None, **kwargs): self.content = content self.template = template or self.template kwargs.setdefault("type", "button") # We turn css_id and css_class into id and class if css_id: kwargs["id"] = css_id kwargs["class"] = self.field_classes if css_class: kwargs["class"] += f" {css_class}" self.flat_attrs = flatatt(kwargs) def render(self, form, context, template_pack=TEMPLATE_PACK, **kwargs): self.content = Template(str(self.content)).render(context) template = self.get_template_name(template_pack) context.update({"button": self}) return render_to_string(template, context.flatten())
[docs]class Container(Div): """ Base class used for `Tab` and `AccordionGroup`, represents a basic container concept. Attributes ---------- template : str The default template which this Layout Object will be rendered with. css_class : str, optional CSS classes to be applied to the ``<div>``. By default "". Parameters ---------- name : str The name of the container. *fields : str, LayoutObject Any number of fields as positional arguments to be rendered within the container. css_id : str, optional A DOM id for the layout object which will be added to the ``<div>`` if provided. By default None. css_class : str, optional Additional CSS classes to be applied in addition to those declared by the class itself. By default None. template : str, optional Overrides the default template, if provided. By default None. **kwargs : dict, optional Additional attributes are passed to ``flatatt`` and converted into key="value", pairs. These attributes are added to the ``<div>``. """ css_class = "" def __init__(self, name, *fields, css_id=None, css_class=None, template=None, active=None, **kwargs): super().__init__(*fields, css_id=css_id, css_class=css_class, template=template, **kwargs) self.name = name self._active_originally_included = active is not None self.active = active or False if not self.css_id: self.css_id = slugify(self.name, allow_unicode=True) def __contains__(self, field_name): """ check if field_name is contained within tab. """ return field_name in map(lambda pointer: pointer[1], self.get_field_names()) def render(self, form, context, template_pack=TEMPLATE_PACK, **kwargs): if self.active: if "active" not in self.css_class: self.css_class += " active" else: self.css_class = self.css_class.replace("active", "") return super().render(form, context, template_pack)
[docs]class ContainerHolder(Div): """ Base class used for `TabHolder` and `Accordion`, groups containers. Attributes ---------- template : str The default template which this Layout Object will be rendered with. css_class : str, optional CSS classes to be applied to the ``<div>``. By default None. Parameters ---------- *fields : str, LayoutObject Any number of fields or layout objects as positional arguments to be rendered within the ``<div>``. css_id : str, optional A DOM id for the layout object which will be added to the ``<div>`` if provided. By default None. css_class : str, optional Additional CSS classes to be applied in addition to those declared by the class itself. By default None. template : str, optional Overrides the default template, if provided. By default None. **kwargs : dict, optional Additional attributes are passed to ``flatatt`` and converted into key="value", pairs. These attributes are added to the ``<div>``. """
[docs] def first_container_with_errors(self, errors): """ Returns the first container with errors, otherwise returns None. """ for tab in self.fields: errors_here = any(error in tab for error in errors) if errors_here: return tab return None
[docs] def open_target_group_for_form(self, form): """ Makes sure that the first group that should be open is open. This is either the first group with errors or the first group in the container, unless that first group was originally set to active=False. """ target = self.first_container_with_errors(form.errors.keys()) if target is None: target = self.fields[0] if not getattr(target, "_active_originally_included", None): target.active = True return target target.active = True return target
[docs]class Tab(Container): """ Tab object. It wraps fields in a div whose default class is "tab-pane" and takes a name as first argument. Attributes ---------- template : str The default template which this Layout Object will be rendered with. css_class : str, optional CSS classes to be applied to the ``<div>``. By default "". Parameters ---------- name : str The name of the container. *fields : str, LayoutObject Any number of fields as positional arguments to be rendered within the container. css_id : str, optional A DOM id for the layout object which will be added to the ``<div>`` if provided. By default None. css_class : str, optional Additional CSS classes to be applied in addition to those declared by the class itself. By default None. template : str, optional Overrides the default template, if provided. By default None. **kwargs : dict, optional Additional attributes are passed to ``flatatt`` and converted into key="value", pairs. These attributes are added to the ``<div>``. Examples -------- Example:: Tab('tab_name', 'form_field_1', 'form_field_2', 'form_field_3') """ css_class = "tab-pane" link_template = "%s/layout/tab-link.html"
[docs]class TabHolder(ContainerHolder): """ TabHolder object. It wraps Tab objects in a container. Attributes ---------- template : str The default template which this Layout Object will be rendered with. css_class : str, optional CSS classes to be applied to the ``<div>``. By default None. Parameters ---------- *fields : str, LayoutObject Any number of fields or layout objects as positional arguments to be rendered within the ``<div>``. css_id : str, optional A DOM id for the layout object which will be added to the ``<div>`` if provided. By default None. css_class : str, optional Additional CSS classes to be applied in addition to those declared by the class itself. By default None. template : str, optional Overrides the default template, if provided. By default None. **kwargs : dict, optional Additional attributes are passed to ``flatatt`` and converted into key="value", pairs. These attributes are added to the ``<div>``. Examples -------- Example:: TabHolder( Tab('form_field_1', 'form_field_2'), Tab('form_field_3') ) """ template = "%s/layout/tab.html" def render(self, form, context, template_pack=TEMPLATE_PACK, **kwargs): for tab in self.fields: tab.active = False # Open the group that should be open. self.open_target_group_for_form(form) content = self.get_rendered_fields(form, context, template_pack) links = "".join(tab.render_link(template_pack) for tab in self.fields) context.update({"tabs": self, "links": links, "content": content}) template = self.get_template_name(template_pack) return render_to_string(template, context.flatten())
[docs]class AccordionGroup(Container): """ Accordion Group (pane) object. It wraps given fields inside an accordion tab. It takes accordion tab name as first argument. Tab object. It wraps fields in a div whose default class is "tab-pane" and takes a name as first argument. Attributes ---------- template : str The default template which this Layout Object will be rendered with. css_class : str, optional CSS classes to be applied to the ``<div>``. By default "". Parameters ---------- name : str The name of the container. *fields : str, LayoutObject Any number of fields as positional arguments to be rendered within the container. css_id : str, optional A DOM id for the layout object which will be added to the ``<div>`` if provided. By default None. css_class : str, optional Additional CSS classes to be applied in addition to those declared by the class itself. By default None. template : str, optional Overrides the default template, if provided. By default None. **kwargs : dict, optional Additional attributes are passed to ``flatatt`` and converted into key="value", pairs. These attributes are added to the ``<div>``. Examples -------- Example:: AccordionGroup("group name", "form_field_1", "form_field_2") """ template = "%s/accordion-group.html" data_parent = "" # accordion parent div id.
[docs]class Accordion(ContainerHolder): """ Accordion menu object. It wraps `AccordionGroup` objects in a container Attributes ---------- template : str The default template which this Layout Object will be rendered with. css_class : str, optional CSS classes to be applied to the ``<div>``. By default None. Parameters ---------- *accordion_groups : str, LayoutObject Any number of layout objects as positional arguments to be rendered within the ``<div>``. css_id : str, optional A DOM id for the layout object which will be added to the ``<div>`` if provided. By default None. css_class : str, optional Additional CSS classes to be applied in addition to those declared by the class itself. By default None. template : str, optional Overrides the default template, if provided. By default None. **kwargs : dict, optional Additional attributes are passed to ``flatatt`` and converted into key="value", pairs. These attributes are added to the ``<div>``. Examples -------- Example:: Accordion( AccordionGroup("group name", "form_field_1", "form_field_2"), AccordionGroup("another group name", "form_field") ) """ template = "%s/accordion.html" def __init__(self, *accordion_groups, css_id=None, css_class=None, template=None, **kwargs): super().__init__(*accordion_groups, css_id=css_id, css_class=css_class, template=template, **kwargs) # Accordion needs to have a unique id if not self.css_id: self.css_id = "-".join(["accordion", str(randint(1000, 9999))]) # AccordionGroup need to have 'data-parent="#Accordion.id"' for accordion_group in accordion_groups: accordion_group.data_parent = self.css_id def render(self, form, context, template_pack=TEMPLATE_PACK, **kwargs): content = "" # Open the group that should be open. self.open_target_group_for_form(form) for group in self.fields: group.data_parent = self.css_id content += render_field(group, form, context, template_pack=template_pack, **kwargs) template = self.get_template_name(template_pack) context.update({"accordion": self, "content": content}) return render_to_string(template, context.flatten())
[docs]class Alert(Div): """ Generates markup in the form of an alert dialog. Attributes ---------- template: str The default template which this Layout Object will be rendered with. css_class : str The CSS classes to be applied to the alert. By defult "alert". Parameters ---------- content : str The content of the alert. dismiss : bool If true the alert contains a button to dismiss the alert. By default True. block : str, optional Additional CSS classes to be applied to the ``<button>``. By default None. css_id : str, optional A DOM id for the layout object which will be added to the alert if provided. By default None. css_class : str, optional Additional CSS classes to be applied in addition to those declared by the class itself. By default None. template : str, optional Overrides the default template, if provided. By default None. **kwargs : dict, optional Additional attributes are passed to ``flatatt`` and converted into key="value", pairs. These attributes are then available in the template context. Examples -------- Example:: Alert(content='<strong>Warning!</strong> Best check yo self, you're not looking too good.') """ template = "%s/layout/alert.html" css_class = "alert" def __init__(self, content, dismiss=True, block=False, css_id=None, css_class=None, template=None, **kwargs): fields = [] if block: self.css_class += " alert-block" super().__init__(*fields, css_id=css_id, css_class=css_class, template=template, **kwargs) self.content = content self.dismiss = dismiss def render(self, form, context, template_pack=TEMPLATE_PACK, **kwargs): template = self.get_template_name(template_pack) context.update({"alert": self, "content": self.content, "dismiss": self.dismiss}) return render_to_string(template, context.flatten())
[docs]class UneditableField(Field): """ Layout object for rendering fields as uneditable in bootstrap. Attributes ---------- template : str The default template which this Layout Object will be rendered with. attrs : dict Attributes to be applied to the field. These are converted into html attributes. e.g. ``data_id: 'test'`` in the attrs dict will become ``data-id='test'`` on the field's ``<input>``. Parameters ---------- *fields : str Usually a single field, but can be any number of fields, to be rendered with the same attributes applied. css_class : str, optional CSS classes to be applied to the field. These are added to any classes included in the ``attrs`` dict. By default ``None``. wrapper_class: str, optional CSS classes to be used when rendering the Field. This class is usually applied to the ``<div>`` which wraps the Field's ``<label>`` and ``<input>`` tags. By default ``None``. template : str, optional Overrides the default template, if provided. By default ``None``. **kwargs : dict, optional Additional attributes are converted into key="value", pairs. These attributes are added to the ``<div>``. Examples -------- Example:: UneditableField('field_name', css_class="input-xlarge") """ template = "%s/layout/uneditable_input.html" def __init__(self, field, *args, **kwargs): self.attrs = {"class": "uneditable-input"} super().__init__(field, *args, **kwargs)
[docs]class InlineField(Field): """ Layout object for rendering fields as Inline in bootstrap. Attributes ---------- template : str The default template which this Layout Object will be rendered with. attrs : dict Attributes to be applied to the field. These are converted into html attributes. e.g. ``data_id: 'test'`` in the attrs dict will become ``data-id='test'`` on the field's ``<input>``. Parameters ---------- *fields : str Usually a single field, but can be any number of fields, to be rendered with the same attributes applied. css_class : str, optional CSS classes to be applied to the field. These are added to any classes included in the ``attrs`` dict. By default ``None``. wrapper_class: str, optional CSS classes to be used when rendering the Field. This class is usually applied to the ``<div>`` which wraps the Field's ``<label>`` and ``<input>`` tags. By default ``None``. template : str, optional Overrides the default template, if provided. By default ``None``. **kwargs : dict, optional Additional attributes are converted into key="value", pairs. These attributes are added to the ``<div>``. Examples -------- Example:: InlineField('field_name') """ template = "%s/layout/inline_field.html"