"""
References
* `Foundation 6 fieldset <https://get.foundation/sites/docs/forms.html#fieldset-styles>`_;
* `Foundation 6 Accordion <https://get.foundation/sites/docs/accordion.html>`_;
* `Foundation 6 Tabs <https://get.foundation/sites/docs/tabs.html>`_;
""" # noqa: E501
from random import randint
from django.template.loader import render_to_string
from crispy_forms import layout as crispy_forms_layout
from crispy_forms.utils import render_field, TEMPLATE_PACK
from crispy_forms import bootstrap as crispy_forms_bootstrap
__all__ = [
'Fieldset', 'Container', 'ContainerHolder', 'TabHolder',
'VerticalTabHolder', 'TabItem', 'AccordionHolder', 'AccordionItem',
]
[docs]class Fieldset(crispy_forms_layout.Fieldset):
"""
It wraps fields in a ``<fieldset>``:
.. code-block:: python
Fieldset("Text for the legend",
'form_field_1',
'form_field_2'
)
The first parameter is the text for the fieldset legend. This text is
context aware, so you can do things like :
.. code-block:: python
Fieldset("Data for {{ user.username }}",
'form_field_1',
'form_field_2'
)
"""
template = "%s/layout/fieldset.html"
[docs]class Container(crispy_forms_bootstrap.Container):
"""
Overrides original Container element to get the "active" classname from
Class attribute ``active_css_class`` so it's compatible with Foundation
5 and 6.
"""
css_class = ""
active_css_class = "active"
def get_active_css_class(self, template_pack):
# Foundation-6 addon only which use unusual class name
if template_pack == 'foundation-6':
return "is-active"
return self.active_css_class
def render(self, form, context, template_pack=TEMPLATE_PACK,
**kwargs):
active_classname = self.get_active_css_class(template_pack)
if self.active:
if active_classname and active_classname not in self.css_class:
self.css_class += ' ' + active_classname
else:
self.css_class = self.css_class.replace(active_classname, '')
return super(Container, self).render(form, context,
template_pack)
[docs]class ContainerHolder(crispy_forms_bootstrap.ContainerHolder):
pass
[docs]class TabHolder(crispy_forms_bootstrap.TabHolder):
"""
Tabs holder object to wrap Tab item objects in a container:
.. code-block:: python
TabHolder(
TabItem('My tab 1', 'form_field_1', 'form_field_2'),
TabItem('My tab 2', 'form_field_3')
)
``TabHolder`` direct children should allways be a ``TabItem`` layout item.
A random id is builded for the tab holder if you don't define it using
``css_id`` argument.
The first ``TabItem`` containing a field error will be marked as
*active* if any, else this will be just the first ``TabItem``.
"""
template = "%s/layout/tab-holder.html"
default_active_tab = None
[docs] def render(self, form, context, template_pack=TEMPLATE_PACK):
"""
Re-implement almost the same code from crispy_forms but passing
``form`` instance to item ``render_link`` method.
"""
links, content = '', ''
# accordion group needs the parent div id to set `data-parent` (I don't
# know why). This needs to be a unique id
if not self.css_id:
self.css_id = "-".join(["tabsholder", str(randint(1000, 9999))])
for tab in self.fields:
tab.active = False
# Activate item
self.open_target_group_for_form(form)
for tab in self.fields:
content += render_field(
tab, form, context, template_pack=template_pack
)
links += tab.render_link(form, template_pack)
context.update({
'tabs': self,
'links': links,
'content': content
})
template = self.get_template_name(template_pack)
return render_to_string(template, context.flatten())
[docs]class VerticalTabHolder(TabHolder):
"""
VerticalTabHolder appends vertical class to TabHolder container
"""
css_class = 'vertical'
[docs]class TabItem(Container):
"""
Tab item object. It wraps fields in a div whose default class is "tabs" and
takes a name as first argument.
Tab item is also responsible of building its associated tab link with its
``render_link`` using the ``link_template`` attribute.
Example:
.. code-block:: python
TabItem('My tab', 'form_field_1', 'form_field_2', 'form_field_3')
``TabItem`` layout item has no real utility out of a ``TabHolder``.
"""
template = "%s/layout/tab-item.html"
link_template = "%s/layout/tab-link.html"
[docs] def has_errors(self, form):
"""
Find tab fields listed as invalid
"""
return any([fieldname_error for fieldname_error in form.errors.keys()
if fieldname_error in self])
[docs] def render_link(self, form, template_pack=TEMPLATE_PACK, **kwargs):
"""
Render the link for the tab-pane. It must be called after render so
``css_class`` is updated with ``active`` class name if needed.
"""
link_template = self.link_template % template_pack
return render_to_string(link_template,
{
'link': self,
'item_has_errors': self.has_errors(form)
})
[docs]class AccordionHolder(crispy_forms_bootstrap.Accordion):
"""
Accordion items holder object to wrap Accordion item objects in a
container:
.. code-block:: python
AccordionHolder(
AccordionItem("group name", "form_field_1", "form_field_2"),
AccordionItem("another group name", "form_field"),
)
``AccordionHolder`` direct children should allways be a ``AccordionItem``
layout item.
A random id is builded for the accordion holder if you don't define it
using ``css_id`` argument.
The first ``AccordionItem`` containing a field error will be marked as
*active* if any, else this will be just the first ``AccordionItem``.
"""
template = "%s/layout/accordion-holder.html"
[docs] def render(self, form, context, template_pack=TEMPLATE_PACK,
**kwargs):
"""
Re-implement almost the same code from crispy_forms but using
``form`` instance to catch field errors.
"""
content = ''
# accordion group needs the parent div id to set `data-parent` (I don't
# know why). This needs to be a unique id
if not self.css_id:
self.css_id = "-".join(["accordion",
str(randint(1000, 9999))])
# Active first 'AccordionItem' containing a field error if any, else
# active first holder item
self.open_target_group_for_form(form)
for group in self.fields:
group.data_parent = self.css_id
group.item_has_errors = any([fieldname_error for fieldname_error in
form.errors.keys()
if fieldname_error in group])
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 AccordionItem(crispy_forms_bootstrap.AccordionGroup):
"""
Accordion item object. It wraps given fields inside an accordion
tab. It takes accordion tab name as first argument.
The item name is also slugified to build an id for the tab if you don't
define it using ``css_id`` argument.
Example:
.. code-block:: python
AccordionItem("group name", "form_field_1", "form_field_2")
"""
template = "%s/layout/accordion-item.html"