Grouping ModelForm fields by Model Field Attributes - django

Question

I've got two models, Question and Project. Project has a ManyToManyField referencing Question:
## models.py
class Question(models.Model):
category = models.CharField(
max_length=4000,
blank=True,
null=True
)
question = models.CharField(
max_length=4000,
blank=True,
null=True
)
class Project(models.Model):
name = models.CharField(
max_length=100,
blank=False,
)
questions = models.ManyToManyField(
Question,
blank=True,
)
From these I have a CreateView and a custom form assigning the CheckboxSelectMultiple widget to the ManyToManyField.
## views.py
class ProjectCreate(LoginRequiredMixin, CreateView):
model = Project
form_class = ProjectForm
## forms.py
class ProjectForm(forms.ModelForm):
class Meta:
model = Project
fields = ['name','questions',]
widgets = {'questions':forms.CheckboxSelectMultiple()}
So, what I want to do now is group the individual labels and checkboxes for the questions CheckboxSelectMultiple form field according to each question's category. Something along the lines of this (not sure exactly how it would work):
{% for field in form.questions %}
{% regroup field by <INSERT MYSTERY CODE> as question_list %}
{% for category, field in question_list %}
{{ category }}
{{ field }}
{% endfor%}
{% endfor %}
EDIT:
A more detailed example of one approach I've tried:
{% for field in form.questions %}
{% regroup field by field.category as question_list %}
{% for category, fields in question_list %}
{{ category }}
{% for f in fields%}
{{ f }}
{% endfor %}
{% endfor%}
{% endfor %}
The above results in TypeError: 'BoundWidget' object is not iterable

Answer 1

I have been trying to figure this out for the best part of a week. I was looking for a simple solution but no luck. The following seems to achieve what you want.
## forms.py
from itertools import groupby
from django import forms
from django.forms.models import ModelChoiceIterator, ModelMultipleChoiceField
from .models import Project, Question
class GroupedModelMultipleChoiceField(ModelMultipleChoiceField):
def __init__(self, group_by_field, group_label=None, *args, **kwargs):
"""
``group_by_field`` is the name of a field on the model
``group_label`` is a function to return a label for each choice group
"""
super(GroupedModelMultipleChoiceField, self).__init__(*args, **kwargs)
self.group_by_field = group_by_field
if group_label is None:
self.group_label = lambda group: group
else:
self.group_label = group_label
def _get_choices(self):
if hasattr(self, '_choices'):
return self._choices
return GroupedModelChoiceIterator(self)
choices = property(_get_choices, ModelMultipleChoiceField._set_choices)
class GroupedModelChoiceIterator(ModelChoiceIterator):
def __iter__(self):
"""Now yields grouped choices."""
if self.field.empty_label is not None:
yield ("", self.field.empty_label)
for group, choices in groupby(
self.queryset.all(),
lambda row: getattr(row, self.field.group_by_field)):
if group is None:
for ch in choices:
yield self.choice(ch)
else:
yield (
self.field.group_label(group),
[self.choice(ch) for ch in choices])
class GroupedCheckboxSelectMultiple(forms.CheckboxSelectMultiple):
def optgroups(self, name, value, attrs=None):
"""
The group name is passed as an argument to the ``create_option`` method (below).
"""
groups = []
has_selected = False
for index, (option_value, option_label) in enumerate(self.choices):
if option_value is None:
option_value = ''
subgroup = []
if isinstance(option_label, (list, tuple)):
group_name = option_value
subindex = 0
choices = option_label
else:
group_name = None
subindex = None
choices = [(option_value, option_label)]
groups.append((group_name, subgroup, index))
for subvalue, sublabel in choices:
selected = (
str(subvalue) in value and
(not has_selected or self.allow_multiple_selected)
)
has_selected |= selected
subgroup.append(self.create_option(
name, subvalue, sublabel, selected, index,
subindex=subindex, attrs=attrs, group=group_name,
))
if subindex is not None:
subindex += 1
return groups
def create_option(self, name, value, label, selected, index, subindex=None, attrs=None, group=None):
"""
Added a ``group`` argument which is included in the returned dictionary.
"""
index = str(index) if subindex is None else "%s_%s" % (index, subindex)
if attrs is None:
attrs = {}
option_attrs = self.build_attrs(self.attrs, attrs) if self.option_inherits_attrs else {}
if selected:
option_attrs.update(self.checked_attribute)
if 'id' in option_attrs:
option_attrs['id'] = self.id_for_label(option_attrs['id'], index)
return {
'name': name,
'value': value,
'label': label,
'selected': selected,
'index': index,
'attrs': option_attrs,
'type': self.input_type,
'template_name': self.option_template_name,
'wrap_label': True,
'group': group,
}
class ProjectForm(forms.ModelForm):
class Meta:
model = Project
fields = ['name', 'questions']
def __init__(self, *args, **kwargs):
super(ProjectForm, self).__init__(*args, **kwargs)
self.fields['questions'] = GroupedModelMultipleChoiceField(
group_by_field='category',
queryset=Question.objects.all(),
widget=GroupedCheckboxSelectMultiple())
Then the following should work in your template:
{% regroup form.questions by data.group as question_list %}
{% for group in question_list %}
<h6>{{ group.grouper|default:"Other Questions" }}</h6>
<ul>
{% for choice in group.list %}
<li>{{ choice }}</li>
{% endfor %}
</ul>
</div>
{% endfor %}
Make sure you add a __str__() method to your Question class so that the question names appear correctly.
You need GroupedModelMultipleChoiceField and GroupedModelChoiceIterator to ensure your choices are properly grouped within the field instance. This means you are able to use {{ form.questions }} in the template to render a structured list.
However, if you want to use the regroup tag in a template, each choice needs to have the group name as an attribute. The GroupedCheckboxSelectMultiple widget provides this.
Credit to the following page for part of the solution:
https://mounirmesselmeni.github.io/2013/11/25/django-grouped-select-field-for-modelchoicefield-or-modelmultiplechoicefield/