From 55bf36f0ff0836f7bad3007be39f29568e16d0be Mon Sep 17 00:00:00 2001
From: Meir <interDist@users.noreply.github.com>
Date: Thu, 11 May 2023 02:25:25 +0200
Subject: [PATCH 1/4] =?UTF-8?q?preparas=20formularan=20kampon=20kaj=20kore?=
 =?UTF-8?q?spondajn=20widgets=20por=20kondi=C4=89oj=20en=20la=20ser=C4=89o?=
 =?UTF-8?q?-formularo?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 hosting/fields.py                             |  42 +++-
 .../templates/ui/widget-tristate_select.html  |  10 +
 hosting/widgets.py                            |  64 ++++++
 tests/forms/test_fields.py                    | 184 ++++++++++++++++++
 tests/forms/test_widgets.py                   | 100 +++++++++-
 5 files changed, 398 insertions(+), 2 deletions(-)
 create mode 100644 hosting/templates/ui/widget-tristate_select.html
 create mode 100644 tests/forms/test_fields.py

diff --git a/hosting/fields.py b/hosting/fields.py
index 68177c37..63a0b310 100644
--- a/hosting/fields.py
+++ b/hosting/fields.py
@@ -13,7 +13,7 @@
     PhoneNumberField as DjangoPhoneNumberField,
 )
 
-from .widgets import TextWithDatalistInput
+from .widgets import MultiNullBooleanSelects, TextWithDatalistInput
 
 
 class StyledEmailField(models.EmailField):
@@ -226,3 +226,43 @@ def to_python(self, value):
         defaults = {'form_class': SuggestiveModelChoiceFormField}
         defaults.update(kwargs)
         return super().formfield(**defaults)
+
+
+class MultiNullBooleanFormField(forms.MultiValueField):
+    widget = MultiNullBooleanSelects
+
+    def __init__(
+            self, base_field, boolean_choices, *args,
+            label_prefix=lambda choice: None, **kwargs,
+    ):
+        self.choices = list(base_field.choices)
+        if isinstance(base_field.choices, forms.models.ModelChoiceIterator):
+            self._single_choice_value = lambda choice: choice.value
+        else:
+            self._single_choice_value = lambda choice: choice
+        field_labels = {
+            self._single_choice_value(choice_value):
+                (choice_label, label_prefix(choice_value))
+            for choice_value, choice_label in self.choices
+        }
+        fields = [
+            forms.NullBooleanField(label=choice_label, required=False)
+            for _, choice_label in self.choices
+        ]
+        super().__init__(
+            fields,
+            *args,
+            required=base_field.required,
+            require_all_fields=False,
+            widget=self.widget(field_labels, boolean_choices),
+            **kwargs)
+        self.empty_values = list(v for v in self.empty_values if v is not None)
+
+    def compress(self, data_list):
+        if not data_list:
+            data_list = [None] * len(self.choices)
+        # Each value of the data_list corresponds to a field.
+        return zip(
+            [self._single_choice_value(choice_value) for choice_value, _ in self.choices],
+            data_list
+        )
diff --git a/hosting/templates/ui/widget-tristate_select.html b/hosting/templates/ui/widget-tristate_select.html
new file mode 100644
index 00000000..b7e93c9f
--- /dev/null
+++ b/hosting/templates/ui/widget-tristate_select.html
@@ -0,0 +1,10 @@
+    <div class="row compact">
+        <div class="col-xs-6">
+            <span class="control-label" id="{{ widget.attrs.id }}_label">
+                {% if widget.label_prefix %}{{ widget.label_prefix }}: {% endif %}{{ widget.label }}
+            </span>
+        </div>
+        <div class="col-xs-6">
+            {% include 'django/forms/widgets/select.html' with widget=widget only %}
+        </div>
+    </div>
diff --git a/hosting/widgets.py b/hosting/widgets.py
index 50806eec..854b9dd3 100644
--- a/hosting/widgets.py
+++ b/hosting/widgets.py
@@ -1,3 +1,5 @@
+import re
+
 from django.forms import widgets as form_widgets
 from django.template.loader import get_template
 from django.utils.safestring import mark_safe
@@ -41,6 +43,68 @@ def get_context(self, name, value, attrs):
         return context
 
 
+class CustomNullBooleanSelect(form_widgets.NullBooleanSelect):
+    template_name = 'ui/widget-tristate_select.html'
+
+    def __init__(self, label, choices, label_prefix=None, attrs=None):
+        """
+        @param `choices` must be an iterable of 2-tuples, where the 1st element of
+        the tuple should be 'unknown', 'true', or 'false', with all three present.
+        """
+        super().__init__(attrs)
+        self.choices = list(choices)
+        self.label = label
+        self.label_prefix = label_prefix
+
+    def get_context(self, name, value, attrs):
+        context = super().get_context(name, value, attrs)
+        context['widget']['label'] = self.label
+        context['widget']['label_prefix'] = self.label_prefix
+        css_class = context['widget']['attrs'].get('class', '')
+        if "form-control" not in css_class:
+            context['widget']['attrs']['class'] = "form-control " + css_class
+        context['widget']['attrs']['aria-labelledby'] = (
+            context['widget']['attrs']['id'] + '_label'
+        )
+        return context
+
+
+class MultiNullBooleanSelects(form_widgets.MultiWidget):
+    def __init__(self, labels, choices_per_label, attrs=None):
+        """
+        @param `labels` is either an iterable or dict of 2-tuples, where the 1st
+        element is the label of the enclosed widget and the 2nd element is the
+        label's prefix (can be None). Dict keys are used as the name suffixes of
+        the enclosed widgets.
+
+        @param `choices_per_label` is an iterable  of 2-tuples, where the 1st
+        element should be 'unknown', 'true', or 'false', with all three present.
+        """
+        if isinstance(labels, dict):
+            widgets = {
+                name: CustomNullBooleanSelect(label, choices_per_label, prefix)
+                for name, (label, prefix) in labels.items()
+            }
+        else:
+            widgets = [
+                CustomNullBooleanSelect(label, choices_per_label, prefix)
+                for label, prefix in labels
+            ]
+        super().__init__(widgets, attrs)
+
+    def id_for_label(self, id_):
+        return id_
+
+    def decompress(self, value):
+        # Typically used when value is not already a simple list of True-False-None.
+        return [
+            selected_value for id, selected_value in (
+                value if isinstance(value, list)
+                else map(lambda v: (None, v), re.split(r',\s*', str(value).strip()))
+            )
+        ]
+
+
 class InlineRadios(CrispyField):
     """
     Form Layout object for rendering radio buttons inline.
diff --git a/tests/forms/test_fields.py b/tests/forms/test_fields.py
new file mode 100644
index 00000000..8da6507a
--- /dev/null
+++ b/tests/forms/test_fields.py
@@ -0,0 +1,184 @@
+from django import forms
+from django.db import models
+from django.test import TestCase, modify_settings, tag
+
+from hosting.fields import MultiNullBooleanFormField
+from hosting.models import Condition
+from hosting.widgets import MultiNullBooleanSelects
+
+from ..assertions import AdditionalAsserts
+from ..factories import ConditionFactory
+
+
+@tag('forms', 'form-fields')
+class MultiNullBooleanFieldTests(AdditionalAsserts, TestCase):
+    ROUND_BAKED_GOODS_OFFER = [(10, "Veggie"), (20, "Funghi"), (30, "Margarita"), (40, "Caprese")]
+    NULL_BOOLEAN_CHOICES = [('true', "yes please"), ('false', "no way"), ('unknown', "whatever")]
+
+    def test_init(self):
+        field = MultiNullBooleanFormField(
+            forms.ChoiceField(choices=self.ROUND_BAKED_GOODS_OFFER),
+            self.NULL_BOOLEAN_CHOICES)
+        # The number of subfields is expected to be equal to the number of choices.
+        self.assertEqual(len(field.fields), 4)
+        # Each subfield is expected to be a NullBooleanField.
+        for f in field.fields:
+            self.assertIsInstance(f, forms.NullBooleanField)
+            self.assertFalse(f.required)
+        self.assertTrue(field.required)
+        # None is expected to not be included in `empty_values`, because it is
+        # a valid value.
+        self.assertNotIn(None, field.empty_values)
+
+    def test_validation(self):
+        field = MultiNullBooleanFormField(
+            forms.ChoiceField(choices=self.ROUND_BAKED_GOODS_OFFER),
+            self.NULL_BOOLEAN_CHOICES)
+
+        # Empty values are expected to fail the validation, because by default
+        # the field has required=True.
+        with self.assertRaises(forms.ValidationError) as cm:
+            field.clean([])
+        self.assertEqual(getattr(cm.exception, 'code', None), 'required')
+        with self.assertRaises(forms.ValidationError) as cm:
+            field.clean('')
+        self.assertEqual(getattr(cm.exception, 'code', None), 'required')
+
+        # Non-empty values are expected to pass the validation, with anything
+        # not recognised as True or False treated as unknown, thus None.
+        with self.assertNotRaises(forms.ValidationError):
+            cleaned_value = field.clean(['x', 'true'])
+        self.assertEqual(
+            list(cleaned_value),
+            [(10, None), (20, True), (30, None), (40, None)]
+        )
+        # A non-empty value which is not a list is expected to be invalid.
+        with self.assertRaises(forms.ValidationError) as cm:
+            field.clean(' z,y,false ')
+        self.assertEqual(getattr(cm.exception, 'code', None), 'invalid')
+
+        field = MultiNullBooleanFormField(
+            forms.ChoiceField(choices=self.ROUND_BAKED_GOODS_OFFER, required=False),
+            self.NULL_BOOLEAN_CHOICES)
+
+        # Empty values for a not required field are expected to be valid.
+        with self.assertNotRaises(forms.ValidationError):
+            cleaned_value = field.clean([])
+        self.assertEqual(
+            list(cleaned_value),
+            [(10, None), (20, None), (30, None), (40, None)]
+        )
+        with self.assertNotRaises(forms.ValidationError):
+            cleaned_value = field.clean('')
+        self.assertEqual(
+            list(cleaned_value),
+            [(10, None), (20, None), (30, None), (40, None)]
+        )
+
+    def test_validation_on_disabled_field(self):
+        field = MultiNullBooleanFormField(
+            forms.ChoiceField(choices=self.ROUND_BAKED_GOODS_OFFER, required=False),
+            self.NULL_BOOLEAN_CHOICES, disabled=True)
+
+        with self.assertNotRaises(forms.ValidationError):
+            cleaned_value = field.clean([None, 0, False])
+        self.assertEqual(
+            list(cleaned_value),
+            [(10, None), (20, False), (30, False), (40, None)]
+        )
+        with self.assertNotRaises(forms.ValidationError):
+            cleaned_value = field.clean(' z,y,false ')
+        self.assertEqual(
+            list(cleaned_value),
+            [(10, None), (20, None), (30, False), (40, None)]
+        )
+
+        with self.assertNotRaises(forms.ValidationError):
+            cleaned_value = field.clean([])
+        self.assertEqual(
+            list(cleaned_value),
+            [(10, None), (20, None), (30, None), (40, None)]
+        )
+        with self.assertNotRaises(forms.ValidationError):
+            cleaned_value = field.clean('')
+        self.assertEqual(
+            list(cleaned_value),
+            [(10, None), (20, None), (30, None), (40, None)]
+        )
+
+    def widget_tests(self, form):
+        with self.subTest(form=form.__class__.__name__):
+            # The default form field widget is expected to be MultiNullBooleanSelects.
+            self.assertIsInstance(form.fields['extra_order'].widget, MultiNullBooleanSelects)
+            # The choices are expected to be split into separate widgets.
+            self.assertEqual(len(form.fields['extra_order'].widget.widgets), 4)
+            # Widget name suffixes are expected to be the choice values.
+            self.assertEqual(
+                form.fields['extra_order'].widget.widgets_names,
+                [f'_{value}' for value, label in form.fields['pizza_choices'].choices]
+            )
+            # Each choice widget is expected to have the 3 null boolean options,
+            # in the order specified in the field's definition.
+            original_choices = list(form.fields['pizza_choices'].choices)
+            for i, w in enumerate(form.fields['extra_order'].widget.widgets):
+                self.assertEqual(w.label, original_choices[i][1])
+                self.assertEqual([k for k, label in w.choices], ['true', 'false', 'unknown'])
+
+            # The HTML element IDs of the choice widgets are expected to be numbered
+            # from 0 to number of choices, while their names are expected to have the
+            # choice value appended.
+            rendered_form = form.as_p()
+            for i in range(4):
+                self.assertIn(f'id="id_extra_order_{i}"', rendered_form)
+                self.assertIn(f'name="extra_order_{original_choices[i][0]}"', rendered_form)
+
+    def test_widget_for_simple_form(self):
+        class TastyForm(forms.Form):
+            pizza_choices = forms.ChoiceField(choices=self.ROUND_BAKED_GOODS_OFFER)
+            extra_order = MultiNullBooleanFormField(pizza_choices, self.NULL_BOOLEAN_CHOICES)
+
+        self.widget_tests(TastyForm())
+
+    @modify_settings(INSTALLED_APPS={
+        'append': 'tests.forms.test_fields',
+    })
+    def test_widget_for_model_form(self):
+        class TastyModel(models.Model):
+            pizza_choices = models.CharField(
+                choices=self.ROUND_BAKED_GOODS_OFFER, blank=False, default=30)
+
+        class TastyModelForm(forms.ModelForm):
+            class Meta:
+                model = TastyModel
+                fields = '__all__'
+
+            def __init__(form_self, *args, **kwargs):
+                super().__init__(*args, **kwargs)
+                form_self.fields['extra_order'] = MultiNullBooleanFormField(
+                    form_self.fields['pizza_choices'], self.NULL_BOOLEAN_CHOICES
+                )
+
+        self.widget_tests(TastyModelForm())
+
+    @modify_settings(INSTALLED_APPS={
+        'append': 'tests.forms.test_fields',
+    })
+    def test_widget_for_foreign_key(self):
+        Condition.objects.all().delete()
+        ConditionFactory.create_batch(4)
+
+        class MightBeTastyModel(models.Model):
+            pizza_choices = models.ManyToManyField(Condition, blank=False)
+
+        class TastyByReferenceModelForm(forms.ModelForm):
+            class Meta:
+                model = MightBeTastyModel
+                fields = ['pizza_choices']
+
+            def __init__(form_self, *args, **kwargs):
+                super().__init__(*args, **kwargs)
+                form_self.fields['extra_order'] = MultiNullBooleanFormField(
+                    form_self.fields['pizza_choices'], self.NULL_BOOLEAN_CHOICES
+                )
+
+        self.widget_tests(TastyByReferenceModelForm())
diff --git a/tests/forms/test_widgets.py b/tests/forms/test_widgets.py
index 17c60597..fbd67092 100644
--- a/tests/forms/test_widgets.py
+++ b/tests/forms/test_widgets.py
@@ -11,7 +11,8 @@
 from factory import Faker
 
 from hosting.widgets import (
-    ClearableWithPreviewImageInput, InlineRadios, TextWithDatalistInput,
+    ClearableWithPreviewImageInput, CustomNullBooleanSelect,
+    InlineRadios, MultiNullBooleanSelects, TextWithDatalistInput,
 )
 from maps.widgets import AdminMapboxGlWidget, MapboxGlWidget
 
@@ -70,6 +71,103 @@ def test_render(self):
         self.assertRegex(result, '<datalist [^>]*id="id_code_field_options"')
 
 
+@tag('forms', 'widgets')
+class CustomNullBooleanSelectWidgetTests(TestCase):
+    NULL_BOOLEAN_CHOICES = [('true', "hij"), ('false', "klm"), ('unknown', "nop")]
+
+    def test_render(self):
+        widget = CustomNullBooleanSelect("Pick one", self.NULL_BOOLEAN_CHOICES)
+
+        result = widget.render('null_bool_field', None, attrs={'id': 'id_bool_field'})
+        self.assertInHTML(
+            '<span id="id_bool_field_label" class="control-label">Pick one</span>',
+            result)
+        self.assertInHTML(
+            '''
+            <select id="id_bool_field" name="null_bool_field"
+                    aria-labelledby="id_bool_field_label" class="form-control">
+                <option value="true">hij</option>
+                <option value="false">klm</option>
+                <option value="unknown" selected>nop</option>
+            </select>
+            ''',
+            result)
+
+        result = widget.render('null_bool_field', True, attrs={'id': 'id_bool_field'})
+        self.assertInHTML('<option value="true" selected>hij</option>', result)
+        self.assertInHTML('<option value="unknown">nop</option>', result)
+
+        result = widget.render('null_bool_field', False, attrs={'id': 'id_bool_field'})
+        self.assertInHTML('<option value="false" selected>klm</option>', result)
+        self.assertInHTML('<option value="unknown">nop</option>', result)
+
+    def test_render_with_prefix(self):
+        widget = CustomNullBooleanSelect("Pick another", self.NULL_BOOLEAN_CHOICES, "Here")
+        result = widget.render('null_bool_field', "?", attrs={'id': 'id_bool_field'})
+        self.assertInHTML(
+            '<span id="id_bool_field_label" class="control-label">Here: Pick another</span>',
+            result)
+        self.assertInHTML('<option value="unknown" selected>nop</option>', result)
+
+    def test_css_class(self):
+        widget = CustomNullBooleanSelect("Don't pick", self.NULL_BOOLEAN_CHOICES)
+
+        result = widget.render(
+            'null_bool_field', "X", attrs={'id': 'id_bool_field', 'class': "fancy"})
+        self.assertRegex(
+            result,
+            r'<select [^>]*class="\s*(fancy\s*form-control|form-control\s*fancy)\s*"'
+        )
+
+        result = widget.render(
+            'null_bool_field', "Y", attrs={'id': 'id_bool_field', 'class': "not-fancy"})
+        self.assertRegex(
+            result,
+            r'<select [^>]*class="\s*(not-fancy\s*form-control|form-control\s*not-fancy)\s*"'
+        )
+
+        result = widget.render(
+            'null_bool_field', "Z",
+            attrs={'id': 'id_bool_field', 'class': "first-level form-control required"})
+        self.assertRegex(
+            result,
+            r'<select [^>]*class="\s*(first-level form-control required)\s*"'
+        )
+
+
+@tag('forms', 'widgets')
+class MultiNullBooleanSelectsWidgetTests(TestCase):
+    def test_render_with_numbering(self):
+        widget = MultiNullBooleanSelects(
+            [("First", "Go"), ("Second", "Stop")],
+            [('false', "kP"), ('unknown', "nM"), ('true', "hS")]
+        )
+        result = widget.render('multi_value_field', [], attrs={'id': 'id_multi_value_field'})
+        self.assertRegex(
+            result, '<span [^>]*id="id_multi_value_field_0_label">Go: First</span>')
+        self.assertRegex(
+            result, '<select\s+name="multi_value_field_0"\s+id="id_multi_value_field_0"')
+        self.assertRegex(
+            result, '<span [^>]*id="id_multi_value_field_1_label">Stop: Second</span>')
+        self.assertRegex(
+            result, '<select\s+name="multi_value_field_1"\s+id="id_multi_value_field_1"')
+
+    def test_render_with_naming(self):
+        widget = MultiNullBooleanSelects(
+            {'go': ("First", None), 'stop': ("Second", None)},
+            [('false', "kP"), ('unknown', "nM"), ('true', "hS")]
+        )
+        result = widget.render('multi_value_field', [], attrs={'id': 'id_multi_value_field'})
+        self.assertRegex(
+            result, '<span [^>]*id="id_multi_value_field_0_label">First</span>')
+        self.assertRegex(
+            result, '<select\s+name="multi_value_field_go"\s+id="id_multi_value_field_0"')
+        self.assertRegex(
+            result, '<span [^>]*id="id_multi_value_field_1_label">Second</span>')
+        self.assertRegex(
+            result, '<select\s+name="multi_value_field_stop"\s+id="id_multi_value_field_1"')
+
+
 @tag('forms', 'widgets')
 class InlineRadiosWidgetTests(TestCase):
     def test_render(self):

From 9babedad6e541f690a34f14f983dfa4f9a81ebee Mon Sep 17 00:00:00 2001
From: Meir <interDist@users.noreply.github.com>
Date: Wed, 2 Aug 2023 18:41:54 +0200
Subject: [PATCH 2/4] =?UTF-8?q?anstata=C5=ADigas=20"faciligojn"=20kaj=20"l?=
 =?UTF-8?q?imigojn"=20en=20la=20ser=C4=89o-formularo=20per=20"kondi=C4=89o?=
 =?UTF-8?q?j"?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

ĉiun kondiĉon eblas inkludi en la rezultoj aŭ ekskludi el ili. laŭ diskuto en
la telegrama grupo kaj preferoj de la uzantoj.
---
 core/static/js/scripts.js                     |   5 +-
 core/static/sass/_all.scss                    |  16 +-
 core/static/sass/_bootstrap_fixes.scss        |   3 +
 hosting/filters/search.py                     |  68 ++-
 hosting/forms/listing.py                      |  19 +-
 hosting/migrations/0066_hosting_conditions.py |   2 +-
 hosting/models.py                             |   2 +-
 hosting/widgets.py                            |  38 +-
 locale/eo/LC_MESSAGES/django.po               |  35 +-
 pasportaservo/templates/bootstrap3/field.html |   2 +-
 .../layout/expanded_select_field.html         |  61 +++
 tests/forms/test_search_forms.py              |  19 +-
 tests/forms/test_widgets.py                   | 410 ++++++++++++++----
 tests/integration/test_filters.py             |  11 +-
 tests/test_filters.py                         | 100 ++++-
 15 files changed, 648 insertions(+), 143 deletions(-)
 create mode 100644 pasportaservo/templates/bootstrap3/layout/expanded_select_field.html

diff --git a/core/static/js/scripts.js b/core/static/js/scripts.js
index 297052f8..3d25f077 100644
--- a/core/static/js/scripts.js
+++ b/core/static/js/scripts.js
@@ -523,11 +523,12 @@ function enableTooltips() {
     function realignTooltip(tip, elem) {
         var placement = getComputedStyle(elem).getPropertyValue('--tooltip-placement').trim()
                         || elem.getAttribute('data-placement') || 'top';
+        var alt_placement = elem.getAttribute('data-alt-placement') == 'top' ? 'top' : 'bottom';
         if (placement == 'left' && elem.getBoundingClientRect().left < 85) {
-            return 'bottom';
+            return alt_placement;
         }
         if (placement == 'right' && elem.getBoundingClientRect().right > window.outerWidth - 85) {
-            return 'bottom';
+            return alt_placement;
         }
         return placement;
     }
diff --git a/core/static/sass/_all.scss b/core/static/sass/_all.scss
index 735b8de4..49c0a344 100644
--- a/core/static/sass/_all.scss
+++ b/core/static/sass/_all.scss
@@ -424,7 +424,7 @@ header:not(.hero) #subtitle {
     box-shadow: 0px 1px 5px 0px darken($color-default-bg, 12%);
     border-top: 0;
 
-    .form-group:first-of-type {
+    .form-group:not([id*="option_1"]):first-of-type {
         margin-top: 15px;
     }
 }
@@ -1243,12 +1243,6 @@ p.tip {
     width: 100%;
     background-color: $color-gray-light;
 }
-#id_facilitations_form_element, #id_restrictions_form_element {
-    .checkbox-inline {
-        margin-left: 0px;
-        margin-right: 10px;
-    }
-}
 
 *[type="password"] + .progress,
 *[type="password"] + .popover + .progress {
@@ -1304,6 +1298,14 @@ textarea {
         min-height: 34px;
     }
 }
+input[type="checkbox"], input[type="radio"] {
+    ~ .select-marker {
+        display: none;
+    }
+    &:checked ~ .select-marker {
+        display: inline-block !important;
+    }
+}
 
 :invalid {
     box-shadow: none;
diff --git a/core/static/sass/_bootstrap_fixes.scss b/core/static/sass/_bootstrap_fixes.scss
index a3a8c104..c5807e1d 100644
--- a/core/static/sass/_bootstrap_fixes.scss
+++ b/core/static/sass/_bootstrap_fixes.scss
@@ -205,6 +205,9 @@ blockquote .table.small:before {
                 margin-top: 1px;
             }
         }
+        .input-group-addon {
+            font-size: 12px;
+        }
     }
 }
 /* MD */
diff --git a/hosting/filters/search.py b/hosting/filters/search.py
index 5fd01ad5..08c2206a 100644
--- a/hosting/filters/search.py
+++ b/hosting/filters/search.py
@@ -1,8 +1,10 @@
 from django import forms
 from django.db import models
+from django.utils.translation import pgettext_lazy
 
 import django_filters as filters
 
+from ..fields import MultiNullBooleanFormField
 from ..forms import SearchForm
 from ..models import Condition, Place
 
@@ -39,6 +41,46 @@ def filter(self, qs, value):
         return super().filter(qs, [tuple(value)])
 
 
+class ModelMultipleChoiceIncludeExcludeFilter(filters.ModelMultipleChoiceFilter):
+    def __init__(self, boolean_choices, *args, label_prefix=lambda choice: None, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.field_boolean_choices = boolean_choices
+        self.option_label_prefix = label_prefix
+
+    @property
+    def field(self):
+        if not hasattr(self, '_field'):
+            base_field = super().field
+
+            self._field = MultiNullBooleanFormField(
+                base_field=base_field,
+                label=base_field.label,
+                label_prefix=self.option_label_prefix,
+                boolean_choices=self.field_boolean_choices,
+            )
+
+        return self._field
+
+    def filter(self, qs, value):
+        value = list(value)
+        include = tuple(choice_value for choice_value, decision in value if decision is True)
+        exclude = tuple(choice_value for choice_value, decision in value if decision is False)
+        base_lookup_expr = self.lookup_expr
+
+        self.exclude = True
+        self.conjoined = False
+        self.lookup_expr = 'in'
+        if exclude:
+            qs = super().filter(qs, [exclude])
+        self.exclude = False
+        self.conjoined = True
+        self.lookup_expr = base_lookup_expr
+        if include:
+            qs = super().filter(qs, include)
+
+        return qs
+
+
 class SearchFilterSet(filters.FilterSet):
     class Meta:
         model = Place
@@ -80,20 +122,22 @@ class Meta:
             },
         }
 
-    # Include only hosts who offer specific facilitations...
-    facilitations = filters.ModelMultipleChoiceFilter(
-        field_name='conditions',
-        conjoined=True,
-        queryset=(
-            Condition.objects.filter(restriction=False).order_by(Condition.active_name_field())
-        ))
-
-    # Exclude hosts who indicated specific restrictions...
-    restrictions = ModelMultipleChoiceExcludeFilter(
+    conditions = ModelMultipleChoiceIncludeExcludeFilter(
         field_name='conditions',
         queryset=(
-            Condition.objects.filter(restriction=True).order_by(Condition.active_name_field())
-        ))
+            Condition.objects.order_by('restriction', Condition.active_name_field())
+        ),
+        boolean_choices=(
+            ('false', pgettext_lazy("Imperative", "exclude")),
+            ('unknown', pgettext_lazy("Imperative", "not important")),
+            ('true', pgettext_lazy("Imperative", "include")),
+        ),
+        label_prefix=lambda choice: (
+            pgettext_lazy("Condition type", "Restriction")
+            if choice.instance.restriction
+            else pgettext_lazy("Condition type", "Facilitation")
+        ),
+    )
 
     def __init__(self, data=None, *args, **kwargs):
         if data is None:
diff --git a/hosting/forms/listing.py b/hosting/forms/listing.py
index a16531ea..c89547e3 100644
--- a/hosting/forms/listing.py
+++ b/hosting/forms/listing.py
@@ -2,9 +2,11 @@
 from django.utils.text import format_lazy
 from django.utils.translation import gettext_lazy as _
 
-from crispy_forms.bootstrap import InlineCheckboxes, PrependedText
+from crispy_forms.bootstrap import PrependedText
 from crispy_forms.helper import FormHelper
 
+from ..widgets import ExpandedMultipleChoice
+
 
 class SearchForm(forms.Form):
 
@@ -25,7 +27,7 @@ def __init__(self, *args, **kwargs):
         self.helper['max_guest'].wrap(
             PrependedText,
             format_lazy('<span class="addon-fw-3">{text}</span>', text=_("guests")),
-            wrapper_class='form-group-sm')
+            wrapper_class=self.helper.wrapper_class)
         self.fields['max_night'].widget.attrs['min'] = 0
         self.fields['max_night'].label = (
             format_lazy('<span class="sr-only">{text}</span>', text=_("At least this many"))
@@ -33,13 +35,13 @@ def __init__(self, *args, **kwargs):
         self.helper['max_night'].wrap(
             PrependedText,
             format_lazy('<span class="addon-fw-3">{text}</span>', text=_("nights")),
-            wrapper_class='form-group-sm')
+            wrapper_class=self.helper.wrapper_class)
         self.fields['contact_before'].widget.attrs['min'] = 1
         self.fields['contact_before'].label = _("Available within")
         self.helper['contact_before'].wrap(
             PrependedText,
             format_lazy('<span class="addon-fw-3">{text}</span>', text=_("days")),
-            wrapper_class='form-group-sm')
+            wrapper_class=self.helper.wrapper_class)
 
         self.fields['available'].initial = True
         self.fields['available'].label = _("Place to sleep")
@@ -47,10 +49,11 @@ def __init__(self, *args, **kwargs):
             self.fields[bool_field].extra_label = self.fields[bool_field].label
             self.fields[bool_field].label = _("Yes")
 
-        self.fields['facilitations'].label = _("Show hosts with such facilitation")
-        self.helper['facilitations'].wrap(InlineCheckboxes, wrapper_class='form-group-sm')
-        self.fields['restrictions'].label = _("Don't show hosts with such restriction")
-        self.helper['restrictions'].wrap(InlineCheckboxes, wrapper_class='form-group-sm')
+        self.helper['conditions'].wrap(
+            ExpandedMultipleChoice,
+            wrapper_class=self.helper.wrapper_class,
+            collapsed=True,
+            option_hover_css_classes={'true': "btn-success", 'false': "btn-danger"})
 
     def clean(self):
         cleaned_data = super().clean()
diff --git a/hosting/migrations/0066_hosting_conditions.py b/hosting/migrations/0066_hosting_conditions.py
index e360e3c5..0f5f79fe 100644
--- a/hosting/migrations/0066_hosting_conditions.py
+++ b/hosting/migrations/0066_hosting_conditions.py
@@ -231,7 +231,7 @@ class Migration(migrations.Migration):
         migrations.AddField(
             model_name='condition',
             name='restriction',
-            field=models.BooleanField(default=True, help_text='Marked = limitation for the guests, unmarked = facilitation for the guests.', verbose_name='is a limitation'),
+            field=models.BooleanField(default=True, help_text='Marked = restriction for the guests, unmarked = facilitation for the guests.', verbose_name='is a limitation'),
         ),
 
         migrations.RunPython(update_existing_conditions, revert_existing_conditions),
diff --git a/hosting/models.py b/hosting/models.py
index 0e4c11c9..c6999dde 100644
--- a/hosting/models.py
+++ b/hosting/models.py
@@ -1288,7 +1288,7 @@ class Categories(models.TextChoices):
     restriction = models.BooleanField(
         _("is a limitation"),
         default=True,
-        help_text=_("Marked = limitation for the guests, "
+        help_text=_("Marked = restriction for the guests, "
                     "unmarked = facilitation for the guests."))
 
     class Meta:
diff --git a/hosting/widgets.py b/hosting/widgets.py
index 854b9dd3..adc759bc 100644
--- a/hosting/widgets.py
+++ b/hosting/widgets.py
@@ -4,7 +4,7 @@
 from django.template.loader import get_template
 from django.utils.safestring import mark_safe
 
-from crispy_forms.layout import Field as CrispyField
+from crispy_forms.layout import Field as CrispyLayoutField
 from crispy_forms.utils import TEMPLATE_PACK
 
 
@@ -105,7 +105,7 @@ def decompress(self, value):
         ]
 
 
-class InlineRadios(CrispyField):
+class InlineRadios(CrispyLayoutField):
     """
     Form Layout object for rendering radio buttons inline.
     """
@@ -123,3 +123,37 @@ def render(self, form, form_style, context, template_pack=TEMPLATE_PACK, **kwarg
             form, form_style, context, template_pack=template_pack,
             extra_context=extra_context
         )
+
+
+class ExpandedMultipleChoice(CrispyLayoutField):
+    """
+    Form Layout object that displays each option of a (Model)MultipleChoiceField
+    as a separate label and a set of buttons corresponding to the choices of that
+    option.
+    """
+    template = '%s/layout/expanded_select_field.html'
+
+    def __init__(
+            self, *args,
+            option_css_classes=None, option_hover_css_classes=None,
+            collapsed=None,
+            **kwargs
+    ):
+        super().__init__(*args, **kwargs)
+        if option_css_classes is not None:
+            self.option_css_classes = option_css_classes
+        else:
+            self.option_css_classes = {}
+        if option_hover_css_classes is not None:
+            self.option_hover_css_classes = option_hover_css_classes
+        else:
+            self.option_hover_css_classes = {}
+        self.collapsed_expanded_block = collapsed
+
+    def render(self, *args, extra_context=None, **kwargs):
+        if extra_context is None:
+            extra_context = {}
+        extra_context['option_css_classes'] = self.option_css_classes
+        extra_context['option_hover_css_classes'] = self.option_hover_css_classes
+        extra_context['field_block_collapsed'] = self.collapsed_expanded_block
+        return super().render(*args, extra_context=extra_context, **kwargs)
diff --git a/locale/eo/LC_MESSAGES/django.po b/locale/eo/LC_MESSAGES/django.po
index 97178d0b..14a19627 100644
--- a/locale/eo/LC_MESSAGES/django.po
+++ b/locale/eo/LC_MESSAGES/django.po
@@ -1704,6 +1704,31 @@ msgstr "Bv. enigu ĝustan telefon-numeron."
 msgid "Integer within a predefined range"
 msgstr "Entjero ene de antaŭdifinita intervalo"
 
+#: hosting/filters/search.py
+msgctxt "Imperative"
+msgid "exclude"
+msgstr "ekskludu"
+
+#: hosting/filters/search.py
+msgctxt "Imperative"
+msgid "not important"
+msgstr "ne gravas"
+
+#: hosting/filters/search.py
+msgctxt "Imperative"
+msgid "include"
+msgstr "inkludu"
+
+#: hosting/filters/search.py
+msgctxt "Condition type"
+msgid "Restriction"
+msgstr "Limigo"
+
+#: hosting/filters/search.py
+msgctxt "Condition type"
+msgid "Facilitation"
+msgstr "Faciligo"
+
 #: hosting/forms/familymembers.py
 msgid "A family member cannot be future-born (even if planned)."
 msgstr "Kunloĝanto ne povas naskiĝi estontece, eĉ se planita."
@@ -1754,14 +1779,6 @@ msgstr "tagoj"
 msgid "Place to sleep"
 msgstr "Dormloko"
 
-#: hosting/forms/listing.py
-msgid "Show hosts with such facilitation"
-msgstr "Montru gastigantojn kun jena faciligo"
-
-#: hosting/forms/listing.py
-msgid "Don't show hosts with such restriction"
-msgstr "Ne montru gastigantojn kun jena limigo"
-
 #: hosting/forms/phones.py
 msgid "You already have this telephone number."
 msgstr "Vi jam indikis tian telefonnumeron."
@@ -2485,7 +2502,7 @@ msgstr "ĉu limigo"
 
 #: hosting/models.py
 msgid ""
-"Marked = limitation for the guests, unmarked = facilitation for the guests."
+"Marked = restriction for the guests, unmarked = facilitation for the guests."
 msgstr "Markita = limigo por la gastoj, malmarkita = faciligo por la gastoj."
 
 #: hosting/models.py hosting/templates/hosting/hosting_condition.html
diff --git a/pasportaservo/templates/bootstrap3/field.html b/pasportaservo/templates/bootstrap3/field.html
index 76bc20d2..70c09353 100644
--- a/pasportaservo/templates/bootstrap3/field.html
+++ b/pasportaservo/templates/bootstrap3/field.html
@@ -56,7 +56,7 @@
                 {% endif %}
             {% else %}
                 {% block controls %}
-                    <div class="controls {{ field_class }}">
+                    <div class="controls {{ field_class }}"{% if field|is_multivalue %} id="{{ field.field.widget.attrs.id|default:field.auto_id }}"{% endif %}>
                         {% block controls_field_before %}{% endblock %}
                         {% block controls_field %}
                             {% if tabindex %}{% crispy_field field "tabindex" tabindex %}{% else %}{% crispy_field field %}{% endif %}
diff --git a/pasportaservo/templates/bootstrap3/layout/expanded_select_field.html b/pasportaservo/templates/bootstrap3/layout/expanded_select_field.html
new file mode 100644
index 00000000..4f34b9b0
--- /dev/null
+++ b/pasportaservo/templates/bootstrap3/layout/expanded_select_field.html
@@ -0,0 +1,61 @@
+{% load crispy_forms_field crispy_forms_filters %}
+{% load expression %}
+{% load compact from utils %}
+
+<div {% filter compact %}
+        id="{{ field.auto_id }}_form_element"
+        {% if field_block_collapsed is not None %}
+            class="collapse when-scripting{% if not field_block_collapsed %} in{% endif %}"
+            aria-expanded="{{ field_block_collapsed|yesno:"false,true" }}"
+        {% endif %}
+     {% endfilter %}>
+    {% for widget in field %}
+    {% for choice in widget.data.subwidgets %}
+        <div id="{{ field.auto_id }}_option_{{ forloop.counter }}_form_element"
+             class="{% filter compact %}
+                        form-group
+                        {% if wrapper_class %} {{ wrapper_class }} {% endif %}
+                        {% if form_show_errors and field.errors %} has-error {% endif %}
+                        {% if field.css_classes %} {{ field.css_classes }} {% endif %}
+                    {% endfilter %}">
+            {% if form_show_labels %}
+                <label id="{{ choice.attrs.id }}_label" for="{{ choice.attrs.id }}"
+                       class="control-label {{ label_class }}{% if field.field.required %} requiredField{% endif %}"
+                       {% if choice.label_prefix %}
+                            title="({{ choice.label_prefix }})"
+                            data-toggle="tooltip" data-placement="left" data-alt-placement="top"
+                       {% endif %}>
+                    {{ choice.label }}
+                </label>
+            {% endif %}
+
+            <div class="controls checkbox {{ field_class }}">
+                <div class="btn-group btn-group-xs btn-group-toggle" id="{{ choice.attrs.id }}" data-toggle="buttons">
+                    {% for group_name, group_choices, group_index in choice.optgroups %}
+                        {% for option in group_choices %}
+                            <label for="{{ choice.attrs.id }}_g{{ group_index }}_v{{ option.index }}"
+                                   class="btn btn-default {% expr option_css_classes[option['value']] %}{% if option.selected %} active{% endif %}"
+                                   data-hover-class="{% expr option_hover_css_classes[option['value']] %}">
+                                {% filter compact %}
+                                   <input type="radio"
+                                          name="{{ option.name }}" id="{{ choice.attrs.id }}_g{{ group_index }}_v{{ option.index }}"
+                                          value="{{ option.value|stringformat:'s' }}"
+                                          {% if option.selected %} checked {% endif %}
+                                          autocomplete="off"
+                                          {% if tabindex %} tabindex="{{ tabindex }}" {% endif %}
+                                          {{ option.attrs|flatatt }}>
+                                {% endfilter %}
+                                {{ option.label }}
+                                <span class="fa fa-solid fa-check select-marker" style="display: none" aria-hidden="true"></span>
+                            </label>
+                        {% endfor %}
+                    {% endfor %}
+                </div>
+                {% if forloop.last %}
+                    {% include 'bootstrap3/layout/help_text_and_errors.html' %}
+                {% endif %}
+            </div>
+        </div>
+    {% endfor %}
+    {% endfor %}
+</div>
diff --git a/tests/forms/test_search_forms.py b/tests/forms/test_search_forms.py
index 69aa1a1f..7102d74d 100644
--- a/tests/forms/test_search_forms.py
+++ b/tests/forms/test_search_forms.py
@@ -23,8 +23,7 @@ def test_init(self):
         # Verify that the expected fields are part of the form.
         expected_fields = """
             max_guest max_night contact_before tour_guide have_a_drink
-            owner__first_name owner__last_name available
-            facilitations restrictions
+            owner__first_name owner__last_name available conditions
         """.split()
         self.assertEqual(set(expected_fields), set(form.fields))
 
@@ -54,17 +53,11 @@ def test_labels_en(self):
         self.assertEqual(form.fields['have_a_drink'].label, "Yes")
         self.assertTrue(hasattr(form.fields['have_a_drink'], 'extra_label'))
         self.assertEqual(form.fields['have_a_drink'].extra_label, "Have a drink")
+        self.assertEqual(form.fields['conditions'].label, "Conditions")
 
         self.assertEqual(form.fields['owner__first_name'].label, "First name")
         self.assertEqual(form.fields['owner__last_name'].label, "Last name")
 
-        self.assertEqual(
-            form.fields['facilitations'].label,
-            "Show hosts with such facilitation")
-        self.assertEqual(
-            form.fields['restrictions'].label,
-            "Don't show hosts with such restriction")
-
     @override_settings(LANGUAGE_CODE='eo')
     def test_labels_eo(self):
         # Workaround due to FilterSet evaluating labels too early.
@@ -86,17 +79,11 @@ def test_labels_eo(self):
         self.assertEqual(form.fields['have_a_drink'].label, "Jes")
         self.assertTrue(hasattr(form.fields['have_a_drink'], 'extra_label'))
         self.assertEqual(form.fields['have_a_drink'].extra_label, "Trinkejumado")
+        self.assertEqual(form.fields['conditions'].label, "Kondiĉoj")
 
         self.assertEqual(form.fields['owner__first_name'].label, "Persona nomo")
         self.assertEqual(form.fields['owner__last_name'].label, "Familia nomo")
 
-        self.assertEqual(
-            form.fields['facilitations'].label,
-            "Montru gastigantojn kun jena faciligo")
-        self.assertEqual(
-            form.fields['restrictions'].label,
-            "Ne montru gastigantojn kun jena limigo")
-
     def test_clean(self):
         # Checking the boolean fields on the form means
         # 'filter by these conditions' and is expected to
diff --git a/tests/forms/test_widgets.py b/tests/forms/test_widgets.py
index fbd67092..9028eae4 100644
--- a/tests/forms/test_widgets.py
+++ b/tests/forms/test_widgets.py
@@ -8,16 +8,24 @@
 from django.template import Context
 from django.test import TestCase, override_settings, tag
 
+from bs4 import BeautifulSoup
 from factory import Faker
 
 from hosting.widgets import (
     ClearableWithPreviewImageInput, CustomNullBooleanSelect,
-    InlineRadios, MultiNullBooleanSelects, TextWithDatalistInput,
+    ExpandedMultipleChoice, InlineRadios,
+    MultiNullBooleanSelects, TextWithDatalistInput,
 )
 from maps.widgets import AdminMapboxGlWidget, MapboxGlWidget
 
 from ..assertions import AdditionalAsserts
 
+HTML_PARSER = 'html.parser'
+
+
+def safe_trim(value):
+    return value.strip() if isinstance(value, str) else value
+
 
 @tag('forms', 'widgets')
 class ClearableWithPreviewImageInputWidgetTests(TestCase):
@@ -112,27 +120,22 @@ def test_render_with_prefix(self):
     def test_css_class(self):
         widget = CustomNullBooleanSelect("Don't pick", self.NULL_BOOLEAN_CHOICES)
 
-        result = widget.render(
-            'null_bool_field', "X", attrs={'id': 'id_bool_field', 'class': "fancy"})
-        self.assertRegex(
-            result,
-            r'<select [^>]*class="\s*(fancy\s*form-control|form-control\s*fancy)\s*"'
-        )
-
-        result = widget.render(
-            'null_bool_field', "Y", attrs={'id': 'id_bool_field', 'class': "not-fancy"})
-        self.assertRegex(
-            result,
-            r'<select [^>]*class="\s*(not-fancy\s*form-control|form-control\s*not-fancy)\s*"'
-        )
-
-        result = widget.render(
-            'null_bool_field', "Z",
-            attrs={'id': 'id_bool_field', 'class': "first-level form-control required"})
-        self.assertRegex(
-            result,
-            r'<select [^>]*class="\s*(first-level form-control required)\s*"'
-        )
+        test_data = [
+            ("X", "fancy"),
+            ("Y", "not-fancy"),
+            ("Z", "first-level form-control required"),
+        ]
+        for value, css_classes in test_data:
+            result = widget.render(
+                'null_bool_field', value,
+                attrs={'id': 'id_bool_field', 'class': css_classes})
+            html = BeautifulSoup(result, HTML_PARSER)
+            select_element = html.find('select')
+            with self.subTest(css_class=css_classes, element=select_element):
+                self.assertIsNotNone(select_element)
+                for css_class in css_classes.split():
+                    self.assertIn(css_class, select_element.attrs['class'])
+                self.assertEqual(select_element.attrs['class'].count("form-control"), 1)
 
 
 @tag('forms', 'widgets')
@@ -143,14 +146,24 @@ def test_render_with_numbering(self):
             [('false', "kP"), ('unknown', "nM"), ('true', "hS")]
         )
         result = widget.render('multi_value_field', [], attrs={'id': 'id_multi_value_field'})
-        self.assertRegex(
-            result, '<span [^>]*id="id_multi_value_field_0_label">Go: First</span>')
-        self.assertRegex(
-            result, '<select\s+name="multi_value_field_0"\s+id="id_multi_value_field_0"')
-        self.assertRegex(
-            result, '<span [^>]*id="id_multi_value_field_1_label">Stop: Second</span>')
-        self.assertRegex(
-            result, '<select\s+name="multi_value_field_1"\s+id="id_multi_value_field_1"')
+        html = BeautifulSoup(result, HTML_PARSER)
+
+        with self.subTest(container=' '.join(result.split())):
+            with self.subTest(widget_qualifier=0):
+                label_element = html.find('span', id='id_multi_value_field_0_label')
+                self.assertIsNotNone(label_element)
+                self.assertEqual(safe_trim(label_element.string), "Go: First")
+                select_element = html.find(
+                    'select', id='id_multi_value_field_0', attrs={'name': 'multi_value_field_0'})
+                self.assertIsNotNone(select_element)
+
+            with self.subTest(widget_qualifier=1):
+                label_element = html.find('span', id='id_multi_value_field_1_label')
+                self.assertIsNotNone(label_element)
+                self.assertEqual(safe_trim(label_element.string), "Stop: Second")
+                select_element = html.find(
+                    'select', id='id_multi_value_field_1', attrs={'name': 'multi_value_field_1'})
+                self.assertIsNotNone(select_element)
 
     def test_render_with_naming(self):
         widget = MultiNullBooleanSelects(
@@ -158,14 +171,24 @@ def test_render_with_naming(self):
             [('false', "kP"), ('unknown', "nM"), ('true', "hS")]
         )
         result = widget.render('multi_value_field', [], attrs={'id': 'id_multi_value_field'})
-        self.assertRegex(
-            result, '<span [^>]*id="id_multi_value_field_0_label">First</span>')
-        self.assertRegex(
-            result, '<select\s+name="multi_value_field_go"\s+id="id_multi_value_field_0"')
-        self.assertRegex(
-            result, '<span [^>]*id="id_multi_value_field_1_label">Second</span>')
-        self.assertRegex(
-            result, '<select\s+name="multi_value_field_stop"\s+id="id_multi_value_field_1"')
+        html = BeautifulSoup(result, HTML_PARSER)
+
+        with self.subTest(container=' '.join(result.split())):
+            with self.subTest(widget_qualifier='go'):
+                label_element = html.find('span', id='id_multi_value_field_0_label')
+                self.assertIsNotNone(label_element)
+                self.assertEqual(safe_trim(label_element.string), "First")
+                select_element = html.find(
+                    'select', id='id_multi_value_field_0', attrs={'name': 'multi_value_field_go'})
+                self.assertIsNotNone(select_element)
+
+            with self.subTest(widget_qualifier='stop'):
+                label_element = html.find('span', id='id_multi_value_field_1_label')
+                self.assertIsNotNone(label_element)
+                self.assertEqual(safe_trim(label_element.string), "Second")
+                select_element = html.find(
+                    'select', id='id_multi_value_field_1', attrs={'name': 'multi_value_field_stop'})
+                self.assertIsNotNone(select_element)
 
 
 @tag('forms', 'widgets')
@@ -176,21 +199,242 @@ class DummyForm(forms.Form):
 
         widget = InlineRadios('the_future')
         result = widget.render(DummyForm(), 'default', Context({}))
-        result = ' '.join(result.split())  # Remove newlines and excessive whitespace.
-        self.assertNotIn('<div class="radio">', result)
-        self.assertRegex(
-            result,
-            '<label [^>]*for="id_the_future_1" [^>]*class="radio-inline *"'
-        )
+        html = BeautifulSoup(result, HTML_PARSER)
+        with self.subTest(container=' '.join(result.split())):
+            self.assertNotIn('<div class="radio">', result)
+            label_element = html.find('label', attrs={'for': 'id_the_future_1'})
+            self.assertIsNotNone(label_element)
+            self.assertIn("radio-inline", label_element.attrs['class'])
 
         widget = InlineRadios('the_future', radio_label_class="mark-me-up")
         result = widget.render(DummyForm(), 'default', Context({}))
-        result = ' '.join(result.split())  # Remove newlines and excessive whitespace.
-        self.assertNotIn('<div class="radio">', result)
-        self.assertRegex(
-            result,
-            '<label [^>]*for="id_the_future_2" [^>]*class="radio-inline mark-me-up *"'
+        html = BeautifulSoup(result, HTML_PARSER)
+        with self.subTest(container=' '.join(result.split())):
+            self.assertNotIn('<div class="radio">', result)
+            label_element = html.find('label', attrs={'for': 'id_the_future_2'})
+            self.assertIsNotNone(label_element)
+            self.assertIn("radio-inline", label_element.attrs['class'])
+            self.assertIn("mark-me-up", label_element.attrs['class'])
+
+
+@tag('forms', 'widgets')
+class ExpandedMultipleChoiceWidgetTests(TestCase):
+    @classmethod
+    def setUpTestData(cls):
+        class MultiSelects(forms.widgets.MultiWidget):
+            def decompress(self, value):
+                return value or []
+
+        class MultiChoicesField(forms.MultiValueField):
+            def __init__(self, *args, **kwargs):
+                super().__init__(*args, **kwargs)
+                self.widget = MultiSelects([f.widget for f in self.fields])
+
+            def compress(self, data_list):
+                return data_list
+
+        class DummyForm(forms.Form):
+            the_past = MultiChoicesField(
+                [
+                    forms.ChoiceField(choices=[
+                        (101, "freshman"), (202, "sophomore"), (303, "junior"), (404, "senior"),
+                    ]),
+                    forms.ChoiceField(choices=[
+                        (True, "diploma"), (False, "certificate"),
+                    ]),
+                ],
+            )
+
+        cls.DummyForm = DummyForm
+
+    def test_render(self):
+        widget = ExpandedMultipleChoice('the_past')
+
+        form = self.DummyForm()
+        result = widget.render(form, 'default', Context({}))
+        html = BeautifulSoup(result, HTML_PARSER)
+        # The form elements are expected to be rendered in a container corresponding
+        # to the form's multi-value field.
+        container_element = html.select('div#id_the_past_form_element')
+        self.assertEqual(len(container_element), 1)
+        self.assertNotIn("collapse", container_element[0].attrs.get('class', {}))
+        self.assertNotIn('aria-expanded', container_element[0].attrs)
+        # No control label is expected to be rendered by default.
+        self.assertEqual(len(html.select('label.control-label')), 0)
+        for i, subfield in enumerate(form.fields['the_past'].fields, start=1):
+            element_id = f'id_the_past_option_{i}_form_element'
+            with self.subTest(container_id=element_id):
+                element = html.find('div', id=element_id, class_="form-group")
+                self.assertIsNotNone(element)
+                subelement = element.find('div', id=f'id_the_past_{i-1}')
+                self.assertIsNotNone(subelement)
+                self.assertIn("btn-group", subelement.attrs['class'])
+                self.assertIn("btn-group-toggle", subelement.attrs['class'])
+                for opt in subfield.choices:
+                    optelement = subelement.find(
+                        'input',
+                        type='radio', attrs={'name': f'the_past_{i-1}', 'value': str(opt[0])})
+                    with self.subTest(option=opt, element=optelement):
+                        self.assertIsNotNone(optelement)
+                        self.assertNotIn('checked', optelement.attrs)
+                        # Each radio input field is expected to be wrapped by a label
+                        # styled as a button with text corresponding to the option.
+                        self.assertEqual(optelement.parent.name, 'label')
+                        self.assertEqual(
+                            optelement.attrs.get('id'), optelement.parent.attrs.get('for'))
+                        self.assertIn("btn", optelement.parent.attrs['class'])
+                        self.assertEqual(''.join(optelement.parent.stripped_strings), opt[1])
+                        # Firefox's caching of radio input field values is expected
+                        # to be disabled.
+                        self.assertEqual(optelement.attrs.get('autocomplete'), 'off')
+                        # A specific keyboard tabbing index for the multi-value field
+                        # is not expected to be set.
+                        self.assertNotIn('tabindex', optelement.attrs)
+
+        form = self.DummyForm({'the_past_0': 303, 'the_past_1': True})
+        result = widget.render(form, 'default', Context({}))
+        html = BeautifulSoup(result, HTML_PARSER)
+        for i, data in enumerate(form.data.items()):
+            for opt in form.fields['the_past'].fields[i].choices:
+                element = html.find(
+                    'input', type='radio', attrs={'name': data[0], 'value': str(opt[0])})
+                with self.subTest(option=opt, selected=opt[0] == data[1], element=element):
+                    self.assertIsNotNone(element)
+                    # Each radio input field is expected to be wrapped by a label
+                    # styled as a button with text corresponding to the option.
+                    self.assertEqual(element.parent.name, 'label')
+                    self.assertIn("btn", element.parent.attrs['class'])
+                    if opt[0] == data[1]:
+                        # A value submitted as form data is expected to be selected.
+                        self.assertIn('checked', element.attrs)
+                        self.assertIn("active", element.parent.attrs['class'])
+                    else:
+                        # Any value not submitted as form data is expected to be not selected.
+                        self.assertNotIn('checked', element.attrs)
+                        self.assertNotIn("active", element.parent.attrs['class'])
+
+    def test_css_classes(self):
+        form = self.DummyForm()
+        widget = ExpandedMultipleChoice(
+            'the_past', wrapper_class="my-container", collapsed=False)
+        result = widget.render(
+            form, 'default',
+            Context({'form_show_labels': True, 'tabindex': 3}),
+        )
+        html = BeautifulSoup(result, HTML_PARSER)
+        # The form elements are expected to be rendered in a collapsible container
+        # corresponding to the form's multi-value field and unfolded by default.
+        container_element = html.find('div', id='id_the_past_form_element')
+        self.assertIsNotNone(container_element)
+        self.assertIn('class', container_element.attrs)
+        self.assertIn("collapse", container_element.attrs['class'])
+        self.assertIn("in", container_element.attrs['class'])
+        self.assertEqual(container_element.attrs.get('aria-expanded'), 'true')
+        for i, subfield in enumerate(form.fields['the_past'].fields, start=1):
+            element_id = f'id_the_past_option_{i}_form_element'
+            with self.subTest(container_id=element_id):
+                # Each subfield of the form's multi-value field is expected to be
+                # wrapped in a form-group with the specified wrapper CSS class.
+                element = html.find('div', id=element_id, class_="form-group")
+                self.assertIsNotNone(element)
+                self.assertIn("my-container", element.attrs['class'])
+                # The control label is expected to be present.
+                label_element = element.label
+                self.assertIsNotNone(label_element)
+                self.assertEqual(label_element.attrs.get('for'), f'id_the_past_{i-1}')
+                self.assertIn("control-label", label_element.attrs['class'])
+                # When the subfield's CSS class is not specified, only the default
+                # classes are expected to be in use.
+                subelement = element.find('div', id=f'id_the_past_{i-1}')
+                self.assertIsNotNone(subelement)
+                self.assertEqual(
+                    set(subelement.parent.attrs['class']),
+                    set(["controls", "checkbox"]))
+                for opt in subfield.choices:
+                    optelement = subelement.find(
+                        'input',
+                        type='radio', attrs={'name': f'the_past_{i-1}', 'value': str(opt[0])})
+                    with self.subTest(option=opt, element=optelement):
+                        self.assertIsNotNone(optelement)
+                        # The specified keyboard tabbing index for the multi-value
+                        # field is expected to be set.
+                        self.assertEqual(optelement.attrs.get('tabindex'), '3')
+                        # The label wrapping each radio input field is expected to
+                        # have no hover CSS class.
+                        self.assertEqual(optelement.parent.name, 'label')
+                        self.assertEqual(
+                            optelement.parent.attrs.get('data-hover-class', ""), "")
+
+        widget = ExpandedMultipleChoice(
+            'the_past',
+            option_css_classes={202: "current-class"},
+            option_hover_css_classes={False: "btn-lg", True: "btn-lg"},
+            collapsed=True)
+        result = widget.render(
+            form, 'default',
+            Context({
+                'form_show_labels': True,
+                'label_class': "custom-label",
+                'field_class': "custom-controls",
+            }),
+        )
+        html = BeautifulSoup(result, HTML_PARSER)
+        # The form elements are expected to be rendered in a collapsible container
+        # corresponding to the form's multi-value field and folded by default.
+        container_element = html.find('div', id='id_the_past_form_element')
+        self.assertIsNotNone(container_element)
+        self.assertIn('class', container_element.attrs)
+        self.assertIn("collapse", container_element.attrs['class'])
+        self.assertNotIn("in", container_element.attrs['class'])
+        self.assertEqual(container_element.attrs.get('aria-expanded'), 'false')
+        # The control labels are expected to be rendered with the specified CSS class.
+        label_elements = html.select('label.control-label')
+        self.assertEqual(len(label_elements), 2)
+        for label_element in label_elements:
+            self.assertIn("custom-label", label_element.attrs['class'])
+        for i, subfield in enumerate(form.fields['the_past'].fields, start=1):
+            # The specified subfield's CSS class is expected to be used.
+            subelement = html.find('div', id=f'id_the_past_{i-1}')
+            self.assertIsNotNone(subelement)
+            self.assertEqual(
+                set(subelement.parent.attrs['class']),
+                set(["custom-controls", "controls", "checkbox"]))
+            for opt in subfield.choices:
+                option_element = subelement.find(
+                    'input',
+                    type='radio', attrs={'name': f'the_past_{i-1}', 'value': str(opt[0])})
+                with self.subTest(option=opt, element=option_element):
+                    self.assertIsNotNone(option_element)
+                    # The labels wrapping the radio input fields are expected to have
+                    # the specified CSS class(es), corresponding to the options, and
+                    # the hover CSS class specified per each option.
+                    label_element = option_element.parent
+                    self.assertEqual(label_element.name, 'label')
+                    if opt[0] in [202]:
+                        presence_assertion = self.assertIn
+                    else:
+                        presence_assertion = self.assertNotIn
+                    presence_assertion("current-class", label_element.attrs['class'])
+                    self.assertNotIn("custom-label", label_element.attrs['class'])
+                    self.assertEqual(
+                        label_element.attrs.get('data-hover-class', ""),
+                        "btn-lg" if opt[0] in [True, False] else ""
+                    )
+
+        widget = ExpandedMultipleChoice('the_past')
+        context = Context({'label_class': "custom-label"})
+        result = widget.render(
+            form, 'default', context,
+            extra_context={'inline_class': "select-inline"},
         )
+        html = BeautifulSoup(result, HTML_PARSER)
+        # No control label is expected to be rendered by default.
+        self.assertEqual(len(html.select('label.control-label')), 0)
+        self.assertEqual(len(html.select('label.custom-label')), 0)
+        # Unknown values in extra rendering context are not supposed to be used.
+        self.assertNotIn('inline_class', context)
+        self.assertNotIn('inline_class', result)
+        self.assertNotIn("select-inline", result)
 
 
 @tag('forms', 'widgets')
@@ -222,48 +466,59 @@ def test_serialize(self):
     def test_render(self):
         widget = self.widget_class(
             {'class': "monkey-patch", 'data-test-z': 99, 'data-test-y': 66, 'data-test-x': 33})
-        help_css_class = 'help' if self.widget_class is AdminMapboxGlWidget else 'help-block'
+        help_css_class = "help" if self.widget_class is AdminMapboxGlWidget else "help-block"
         with override_settings(LANGUAGE_CODE='en'):
             result = widget.render('location_field', None, attrs={'id': 'id_location_field'})
-            result = ' '.join(result.split())
+            dom_tree = BeautifulSoup(result, HTML_PARSER)
             # The template fragment is expected to include the container for the dynamic map.
-            self.assertIn('<div id="map"></div>', result)
+            map_container_element = dom_tree.find('div', id='map')
+            self.assertIsNotNone(map_container_element)
+            self.assertEqual(len(map_container_element.contents), 0)
             # The template fragment is expected to include a fallback for no JavaScript.
-            self.assertIn('<noscript>', result)
+            noscript_element = dom_tree.find('noscript')
+            self.assertIsNotNone(noscript_element)
             # A note about technical requirements is expected.
-            self.assertIn("The map requires JavaScript and the WebGL technology.", result)
+            self.assertIn(
+                "The map requires JavaScript and the WebGL technology.",
+                noscript_element.stripped_strings)
             # A help text is expected.
-            self.assertInHTML(
-                f'<p class="{help_css_class}">'
-                "Select manually the most suitable point on the map."
-                '</p>',
-                result)
-            self.assertRegex(
-                result,
-                'id="id_location_field" [^>]*class="[^"]*monkey-patch[^"]*" [^>]*'
-                'data-test-z="99" data-test-y="66" data-test-x="33"[^>]*?></'
-            )
+            help_element = dom_tree.find('p', help_css_class)
+            self.assertIsNotNone(help_element)
+            self.assertEqual(
+                safe_trim(help_element.string),
+                "Select manually the most suitable point on the map.")
+            # The location field is expected to include the specified attributes.
+            field_element = dom_tree.find(id='id_location_field')
+            self.assertIsNotNone(field_element)
+            self.assertIn("monkey-patch", field_element.attrs['class'])
+            self.assertEqual(field_element.attrs.get('data-test-x'), '33')
+            self.assertEqual(field_element.attrs.get('data-test-y'), '66')
+            self.assertEqual(field_element.attrs.get('data-test-z'), '99')
         with override_settings(LANGUAGE_CODE='eo'):
             result = widget.render(
                 'location_field',
                 GeoPoint(44.342639, -75.924861),
                 attrs={'id': 'id_location_field'})
-            result = ' '.join(result.split())
+            dom_tree = BeautifulSoup(result, HTML_PARSER)
             # A translated note about technical requirements is expected.
-            self.assertIn("La mapo necesigas JavaSkripton kaj la teĥnologion WebGL.", result)
+            noscript_element = dom_tree.find('noscript')
+            self.assertIsNotNone(noscript_element)
+            self.assertIn(
+                "La mapo necesigas JavaSkripton kaj la teĥnologion WebGL.",
+                noscript_element.stripped_strings)
             # A translated help text is expected.
-            self.assertInHTML(
-                f'<p class="{help_css_class}">'
-                "Elektu permane la plej taŭgan punkton sur la mapo."
-                '</p>',
-                result)
+            help_element = dom_tree.find('p', help_css_class)
+            self.assertIsNotNone(help_element)
+            self.assertEqual(
+                safe_trim(help_element.string),
+                "Elektu permane la plej taŭgan punkton sur la mapo.")
+            # The location field is expected to include the specified GeoPoint.
             self.assertInHTML(
                 html.escape(GeoPoint(44.342639, -75.924861).json),
                 result)
-            self.assertRegex(
-                result,
-                'id="id_location_field" .*?>[^<]+?coordinates'
-            )
+            field_element = dom_tree.find(id='id_location_field')
+            self.assertIsNotNone(field_element)
+            self.assertRegex(field_element.string, r'\Wcoordinates\W')
 
     def test_selectable_zoom(self):
         widget = self.widget_class({'data-selectable-zoom': 3})
@@ -275,7 +530,10 @@ def test_selectable_zoom(self):
                 "It will be possible to register the point when the resolution of the map allows "
                 "for visible distances of about 1km or less.",
                 result)
-            self.assertRegex(result, 'id="id_position_field" [^>]*data-selectable-zoom="3"')
+            dom_tree = BeautifulSoup(result, HTML_PARSER)
+            field_element = dom_tree.find(id='id_position_field')
+            self.assertIsNotNone(field_element)
+            self.assertEqual(field_element.attrs.get('data-selectable-zoom'), '3')
         with override_settings(LANGUAGE_CODE='eo'):
             result = widget.render('position_field', None, attrs={'id': 'id_position_field'})
             result = ' '.join(result.split())
diff --git a/tests/integration/test_filters.py b/tests/integration/test_filters.py
index 8c06e775..757f6018 100644
--- a/tests/integration/test_filters.py
+++ b/tests/integration/test_filters.py
@@ -1,10 +1,11 @@
 from django.test import TestCase, tag
 from django.utils import timezone
 
-from django_filters import BooleanFilter, CharFilter, ModelMultipleChoiceFilter
+from django_filters import BooleanFilter, CharFilter
 
 from hosting.filters.search import (
-    ModelMultipleChoiceExcludeFilter, NumberOrNoneFilter, SearchFilterSet,
+    ModelMultipleChoiceIncludeExcludeFilter,
+    NumberOrNoneFilter, SearchFilterSet,
 )
 from hosting.forms.listing import SearchForm
 from hosting.models import Place
@@ -20,8 +21,7 @@ def test_init(self):
         # Verify that the expected filters are part of the filterset.
         expected_filters = """
             max_guest max_night contact_before tour_guide have_a_drink
-            owner__first_name owner__last_name available
-            facilitations restrictions
+            owner__first_name owner__last_name available conditions
         """.split()
         self.assertEqual(set(expected_filters), set(filterset.filters))
 
@@ -34,8 +34,7 @@ def test_init(self):
         self.assertIs(type(filterset.filters['owner__first_name']), CharFilter)
         self.assertIs(type(filterset.filters['owner__last_name']), CharFilter)
         self.assertIs(type(filterset.filters['available']), BooleanFilter)
-        self.assertIs(type(filterset.filters['facilitations']), ModelMultipleChoiceFilter)
-        self.assertIs(type(filterset.filters['restrictions']), ModelMultipleChoiceExcludeFilter)
+        self.assertIs(type(filterset.filters['conditions']), ModelMultipleChoiceIncludeExcludeFilter)
 
         # Verify the comparison operations performed by numeric filters.
         self.assertEqual(filterset.filters['max_guest'].lookup_expr, 'gte')
diff --git a/tests/test_filters.py b/tests/test_filters.py
index 87df9e78..1c6bb3e7 100644
--- a/tests/test_filters.py
+++ b/tests/test_filters.py
@@ -1,12 +1,16 @@
-from unittest.mock import Mock
+from unittest.mock import Mock, call
 
 from django.db.models import Q
 from django.test import TestCase, tag
 
+from hosting.fields import MultiNullBooleanFormField
 from hosting.filters.search import (
-    ModelMultipleChoiceExcludeFilter, NumberOrNoneFilter,
+    ModelMultipleChoiceExcludeFilter,
+    ModelMultipleChoiceIncludeExcludeFilter, NumberOrNoneFilter,
 )
 
+from .factories import GenderFactory
+
 
 @tag('search', 'filters')
 class NumberOrNoneFilterTests(TestCase):
@@ -131,3 +135,95 @@ def test_filter_distinct(self):
         self.queryset.distinct.assert_not_called()
         self.queryset.exclude.assert_called_once_with(Q(dummy_field__in=(136,)))
         self.queryset.filter.assert_not_called()
+
+
+@tag('search', 'filters')
+class ModelMultipleChoiceIncludeExcludeFilterTests(TestCase):
+    BOOLEAN_CHOICES = [('true', "hij"), ('false', "klm"), ('unknown', "nop")]
+
+    @classmethod
+    def setUpTestData(cls):
+        cls.queryset = Mock(spec=['filter', 'exclude', 'distinct', 'query'])
+        cls.queryset.filter.return_value = cls.queryset
+        cls.queryset.exclude.return_value = cls.queryset
+        cls.queryset.distinct.return_value = cls.queryset
+
+        GenderFactory.create_batch(5)
+        cls.model = GenderFactory._meta.model
+        cls.model_all_objects = cls.model.objects.all()
+
+    def test_init(self):
+        f = ModelMultipleChoiceIncludeExcludeFilter(self.BOOLEAN_CHOICES, field_name='dummy_field')
+        self.assertEqual(f.lookup_expr, 'exact')
+        self.assertTrue(f.distinct)
+
+    def test_field(self):
+        f = ModelMultipleChoiceIncludeExcludeFilter(
+            self.BOOLEAN_CHOICES, queryset=self.model.objects, field_name='dummy_field')
+        self.assertIsInstance(f.field, MultiNullBooleanFormField)
+        self.assertEqual(f.field.label, None)
+        for i, w in enumerate(f.field.widget.widgets):
+            self.assertEqual(w.label, str(self.model_all_objects[i]))
+            self.assertIsNone(w.label_prefix)
+            self.assertEqual(w.choices, self.BOOLEAN_CHOICES)
+
+    def test_field_labelling(self):
+        f = ModelMultipleChoiceIncludeExcludeFilter(
+            self.BOOLEAN_CHOICES, queryset=self.model.objects, field_name='dummy_field')
+        f.model = self.model
+        self.assertEqual(f.field.label, "[invalid name]")
+
+        f = ModelMultipleChoiceIncludeExcludeFilter(
+            self.BOOLEAN_CHOICES, queryset=self.model.objects, field_name='name_en')
+        f.model = self.model
+        self.assertEqual(
+            f.field.label.upper(),
+            self.model._meta.get_field('name_en').verbose_name.upper())
+        for w in f.field.widget.widgets:
+            self.assertIsNone(w.label_prefix)
+
+        f = ModelMultipleChoiceIncludeExcludeFilter(
+            self.BOOLEAN_CHOICES, queryset=self.model.objects, field_name='name_en',
+            label_prefix=lambda choice: choice.instance.name_en[0].upper())
+        f.model = self.model
+        for i, w in enumerate(f.field.widget.widgets):
+            self.assertEqual(w.label_prefix, self.model_all_objects[i].name_en[0].upper())
+
+    def test_filter_empty_value(self):
+        f = ModelMultipleChoiceIncludeExcludeFilter(self.BOOLEAN_CHOICES, field_name='dummy_field')
+        self.queryset.reset_mock()
+        f.filter(self.queryset, [])
+        self.queryset.filter.assert_not_called()
+        self.queryset.exclude.assert_not_called()
+
+    def test_filter(self):
+        f = ModelMultipleChoiceIncludeExcludeFilter(self.BOOLEAN_CHOICES, field_name='dummy_field')
+
+        self.queryset.reset_mock()
+        f.filter(self.queryset, [(1, True), (3, False), (5, None), (7, None)])
+        self.queryset.exclude.assert_called_once_with(Q(dummy_field__in=(3, )))
+        self.queryset.filter.assert_called_once_with(dummy_field=1)
+
+        self.queryset.reset_mock()
+        f.filter(self.queryset, [(1, True), (3, False), (2, True), (5, None), (4, False)])
+        self.queryset.exclude.assert_called_once_with(Q(dummy_field__in=(3, 4)))
+        self.queryset.filter.assert_has_calls(
+            [call(dummy_field=2), call(dummy_field=1)],
+            any_order=True)
+
+        f = ModelMultipleChoiceIncludeExcludeFilter(self.BOOLEAN_CHOICES, field_name='id')
+        odd_objects = [obj.id for obj in self.model_all_objects if obj.id % 2]
+        even_objects = [obj.id for obj in self.model_all_objects if obj.id % 2 == 0]
+
+        query = [(id, False) for id in odd_objects][:-1]
+        result = f.filter(self.model.objects, query)
+        self.assertQuerysetEqual(
+            result, even_objects + [odd_objects[-1]], lambda o: o.pk, ordered=False)
+
+        query += [(even_objects[1], True)]
+        result = f.filter(self.model.objects, query)
+        self.assertQuerysetEqual(result, [even_objects[1]], lambda o: o.pk)
+
+        query += [(odd_objects[-1], True)]
+        result = f.filter(self.model.objects, query)
+        self.assertQuerysetEqual(result, [])

From 704df48e25136d095b48198e26a21462a7c6d406 Mon Sep 17 00:00:00 2001
From: Meir <interDist@users.noreply.github.com>
Date: Fri, 11 Aug 2023 17:23:01 +0200
Subject: [PATCH 3/4] =?UTF-8?q?aldonas=20horizontale-dividan=20elementon?=
 =?UTF-8?q?=20por=20formularoj=20(ser=C4=89a=20kaj=20lo=C4=9Deja)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 core/static/js/forms.js                       |  20 ++
 core/static/sass/_all.scss                    |  57 ++++
 hosting/forms/listing.py                      |  11 +-
 hosting/forms/places.py                       |   3 +
 hosting/templates/ui/widget-form_divider.html |  24 ++
 hosting/widgets.py                            |  47 +++
 locale/eo/LC_MESSAGES/django.po               |   2 +
 tests/assertions.py                           |  26 ++
 tests/forms/test_fields.py                    |   4 +-
 tests/forms/test_widgets.py                   | 273 +++++++++++++++++-
 10 files changed, 450 insertions(+), 17 deletions(-)
 create mode 100644 hosting/templates/ui/widget-form_divider.html

diff --git a/core/static/js/forms.js b/core/static/js/forms.js
index 86c01445..75f62559 100644
--- a/core/static/js/forms.js
+++ b/core/static/js/forms.js
@@ -381,6 +381,26 @@ $(function() {
         $('#id_test_email').closest('.form-group').toggle($(this).val() === "test");
     }).change();
 
+    /* dynamic (collapsible) form area management */
+    $('[id$="_form_element"].collapse').each(function() {
+        var $switch = $('[aria-controls='+this.id+']');
+        var toggler = function(state) {
+            $switch.attr('aria-expanded', state).children('.fa').each(function() {
+                var $this = $(this);
+                var label = $this.attr('aria-label');
+                $this.attr('aria-label', $this.data('aria-label-inactive'))
+                     .data('aria-label-inactive', label);
+                if (state)
+                    $this.addClass('fa-rotate-90');
+                else
+                    $this.removeClass('fa-rotate-90');
+                window.setTimeout(function() { $this.parent().removeClass('initial'); }, 100);
+            });
+        };
+        $(this).on('show.bs.collapse hide.bs.collapse',
+                   function(event) { toggler(event.type == 'show') });
+    });
+
     /* form cancel button enhancement */
     $('#id_form_cancel').each(function() {
         this.setAttribute('data-default-href', this.getAttribute('href'));
diff --git a/core/static/sass/_all.scss b/core/static/sass/_all.scss
index 49c0a344..3a224ab5 100644
--- a/core/static/sass/_all.scss
+++ b/core/static/sass/_all.scss
@@ -1243,6 +1243,53 @@ p.tip {
     width: 100%;
     background-color: $color-gray-light;
 }
+.divider-heading {
+    overflow: hidden;
+    text-align: center;
+    color: lighten($color-text, 15%);
+
+    &::before, &::after {
+        content: "";
+        display: inline-block;
+        position: relative;
+        vertical-align: middle;
+        width: 50%;
+        height: 3px;
+        border-top: 1px #ccc solid;
+        border-bottom: 1px #eee solid;
+    }
+    &.has-content {
+        &::before {
+            right: 1em;
+            margin-left: -50%;
+        }
+        &::after {
+            left: 1em;
+            margin-right: -50%;
+        }
+        &.as-label {
+            font-weight: 700;
+            color: $color-text;
+        }
+    }
+}
+.switch.btn-sm ~ .divider-heading {
+    padding-top: 4px;
+    width: calc(100% - 50px);
+    float: right;
+}
+.switch.btn-xs ~ .divider-heading {
+    padding-top: 2px;
+    width: calc(100% - 40px);
+    float: right;
+}
+.form-divider {
+    margin-bottom: 15px;
+
+    .switch:not(.initial) .fa {
+        transition: all 0.3s ease-in;
+    }
+}
 
 *[type="password"] + .progress,
 *[type="password"] + .popover + .progress {
@@ -1482,6 +1529,16 @@ input[type="checkbox"], input[type="radio"] {
             max-width: 60%;
         }
     }
+    .form-horizontal .form-divider-sm {
+        font-size: 12px;
+
+        .switch.btn-sm ~ .divider-heading {
+            padding-top: 6px;
+        }
+        .switch.btn-xs ~ .divider-heading {
+            padding-top: 3px;
+        }
+    }
 }
 /* MD */
 @media (min-width: #{$BOOTSTRAP-MD}) {
diff --git a/hosting/forms/listing.py b/hosting/forms/listing.py
index c89547e3..e1ec1399 100644
--- a/hosting/forms/listing.py
+++ b/hosting/forms/listing.py
@@ -5,7 +5,7 @@
 from crispy_forms.bootstrap import PrependedText
 from crispy_forms.helper import FormHelper
 
-from ..widgets import ExpandedMultipleChoice
+from ..widgets import ExpandedMultipleChoice, FormDivider
 
 
 class SearchForm(forms.Form):
@@ -49,6 +49,15 @@ def __init__(self, *args, **kwargs):
             self.fields[bool_field].extra_label = self.fields[bool_field].label
             self.fields[bool_field].label = _("Yes")
 
+        self.helper.layout.insert(
+            self.helper.layout.fields.index('conditions'),
+            FormDivider(
+                title=self.fields['conditions'].label,
+                collapse_field_name='conditions',
+                collapsed=True,
+                wrapper_class="form-divider-sm",
+            )
+        )
         self.helper['conditions'].wrap(
             ExpandedMultipleChoice,
             wrapper_class=self.helper.wrapper_class,
diff --git a/hosting/forms/places.py b/hosting/forms/places.py
index e7d0bdce..ad77e779 100644
--- a/hosting/forms/places.py
+++ b/hosting/forms/places.py
@@ -21,6 +21,7 @@
 from core.auth import AuthRole
 from core.models import SiteConfiguration
 from core.utils import join_lazy, mark_safe_lazy, sort_by
+from hosting.widgets import FormDivider
 from maps import SRID
 from maps.widgets import MapboxGlWidget
 
@@ -94,6 +95,8 @@ def __init__(self, *args, **kwargs):
         # Bigger input area for the address by default.
         self.fields['address'].widget.attrs['rows'] = 2
         self.fields['address'].widget.attrs['autocomplete'] = 'street-address'
+        # Split address details from the description and conditions.
+        self.helper.layout.insert(self.helper.layout.fields.index('max_guest'), FormDivider())
         # Combine the count fields together in one line (index is shifted because of postcode+city layout change).
         max_guests_field_index = self._meta.fields.index('max_guest')
         self.helper[max_guests_field_index-1:max_guests_field_index+2].wrap_together(Div, css_class='row')
diff --git a/hosting/templates/ui/widget-form_divider.html b/hosting/templates/ui/widget-form_divider.html
new file mode 100644
index 00000000..8782cf4e
--- /dev/null
+++ b/hosting/templates/ui/widget-form_divider.html
@@ -0,0 +1,24 @@
+{% load i18n variable %}
+    <div class="form-divider{% if wrapper_class %} {{ wrapper_class }}{% endif %}">
+        {% if collapse_form_field_id %}
+            <button type="button" id="{{ collapse_form_field_id }}_switch"
+                    class="switch requires-scripting hidden-print btn {{ switch_button_class }}"
+                    {% if tabindex %}tabindex="{{ tabindex }}"{% endif %}
+                    data-target="#{{ collapse_form_field_id }}_form_element" data-toggle="collapse"
+                    aria-controls="{{ collapse_form_field_id }}_form_element" aria-expanded="{{ field_block_collapsed|yesno:"false,true" }}">
+                {% asvar aria_label_prefix trimmed %}
+                    {% if collapse_form_field_label or divider_title %}
+                        {{ collapse_form_field_label|default:divider_title }}:
+                    {% endif %}
+                {% endasvar %}
+                &nbsp;<span class="fa fa-caret-right{% if not field_block_collapsed %} fa-rotate-90{% endif %} fa-lg"
+                            aria-label="{{ aria_label_prefix }} {% if field_block_collapsed %}{% trans "Show" %}{% else %}{% trans "Hide" %}{% endif %} "
+                            data-aria-label-inactive="{{ aria_label_prefix }} {% if field_block_collapsed %}{% trans "Hide" %}{% else %}{% trans "Show" %}{% endif %} "></span>&nbsp;
+            </button>
+        {% endif %}
+        {% if divider_title and form_show_labels %}
+            <div class="divider-heading has-content as-label" aria-role="separator">{{ divider_title }}</div>
+        {% else %}
+            <div class="divider-heading"></div>
+        {% endif %}
+    </div>
diff --git a/hosting/widgets.py b/hosting/widgets.py
index adc759bc..54c11462 100644
--- a/hosting/widgets.py
+++ b/hosting/widgets.py
@@ -157,3 +157,50 @@ def render(self, *args, extra_context=None, **kwargs):
         extra_context['option_hover_css_classes'] = self.option_hover_css_classes
         extra_context['field_block_collapsed'] = self.collapsed_expanded_block
         return super().render(*args, extra_context=extra_context, **kwargs)
+
+
+class FormDivider:
+    """
+    Form Layout object for rendering a horizontal divider line on the form, with
+    an optional title. The object cannot wrap other fields and should be used as
+    a standalone element. It can optionally show a button for collapsing and
+    un-collapsing a different form element, either given directly by its id or
+    indirectly via the form field's name if the element corresponds to a field.
+    """
+    template_name = 'ui/widget-form_divider.html'
+
+    def __init__(
+            self, *,
+            title=None, wrapper_class=None,
+            collapse_field_name=None,
+            collapse_field_id=None, collapse_field_label=None,
+            collapsed=None,
+            switch_button_class="btn-sm",
+    ):
+        self.divider_title = title
+        self.wrapper_class = wrapper_class
+        self.next_field = {
+            'name': collapse_field_name,
+            'id': collapse_field_id,
+            'label': collapse_field_label,
+            'collapsed': collapsed,
+        }
+        self.switch_button_class = switch_button_class
+
+    def render(self, form, form_style, context, extra_context=None, **kwargs):
+        if extra_context is None:
+            extra_context = {}
+        if self.next_field['name'] and not self.next_field['id']:
+            self.next_field['id'] = form[self.next_field['name']].auto_id
+            self.next_field['label'] = form[self.next_field['name']].label
+        extra_context.update({
+            'divider_title': self.divider_title,
+            'wrapper_class': self.wrapper_class,
+            'collapse_form_field_id': self.next_field['id'],
+            'collapse_form_field_label': self.next_field['label'],
+            'field_block_collapsed': self.next_field['collapsed'],
+            'switch_button_class': self.switch_button_class,
+        })
+        template = get_template(self.template_name)
+        with context.update(extra_context):
+            return template.render(context.flatten())
diff --git a/locale/eo/LC_MESSAGES/django.po b/locale/eo/LC_MESSAGES/django.po
index 14a19627..99f745a4 100644
--- a/locale/eo/LC_MESSAGES/django.po
+++ b/locale/eo/LC_MESSAGES/django.po
@@ -905,6 +905,7 @@ msgstr "Vi sendis %(nb)s mesaĝojn. Bonege!"
 #: core/templates/ui/fragment-datalist_fallback.html
 #: hosting/templates/hosting/place_detail.html
 #: hosting/templates/hosting/snippets/travel_advice.html
+#: hosting/templates/ui/widget-form_divider.html
 #: pages/templates/pages/supervisors.html
 msgid "Hide"
 msgstr "Kaŝi"
@@ -2934,6 +2935,7 @@ msgid "Print map"
 msgstr "Printi mapon"
 
 #: hosting/templates/hosting/place_detail.html
+#: hosting/templates/ui/widget-form_divider.html
 msgid "Show"
 msgstr "Montri"
 
diff --git a/tests/assertions.py b/tests/assertions.py
index efaacc23..01456343 100644
--- a/tests/assertions.py
+++ b/tests/assertions.py
@@ -59,6 +59,32 @@ def assertEqual(self, obj1, obj2, msg=None):
         else:
             super().assertEqual(obj1, obj2, msg=msg)
 
+    def assertLength(self, objects, value, msg=None):
+        """
+        Asserts that an iterable has a specified number of items.
+        """
+        actual_length = len(objects)
+        if actual_length != value:
+            def truncate_repr(obj):
+                string = " ".join(repr(obj).split())
+                if len(string) > 52:
+                    string = string[:50] + "[...]"
+                return f"{obj.__class__.__qualname__} {string}"
+
+            failure_message = (
+                f"{actual_length} != {value}\n"
+                + f"Object of type {objects.__class__.__qualname__} "
+            )
+            if actual_length > 0:
+                failure_message += (
+                    "has the following items:\n"
+                    + ", ".join(truncate_repr(item) for item in objects)
+                    + ("\n" if msg else "")
+                )
+            else:
+                failure_message += "has no items"
+            self.fail(self._formatMessage(msg, failure_message))
+
     class _AssertNotRaisesContext(_AssertRaisesContext):
         def __exit__(self, exc_type, exc_value, tb):
             if exc_type is not None:
diff --git a/tests/forms/test_fields.py b/tests/forms/test_fields.py
index 8da6507a..59bbe5f3 100644
--- a/tests/forms/test_fields.py
+++ b/tests/forms/test_fields.py
@@ -20,7 +20,7 @@ def test_init(self):
             forms.ChoiceField(choices=self.ROUND_BAKED_GOODS_OFFER),
             self.NULL_BOOLEAN_CHOICES)
         # The number of subfields is expected to be equal to the number of choices.
-        self.assertEqual(len(field.fields), 4)
+        self.assertLength(field.fields, 4)
         # Each subfield is expected to be a NullBooleanField.
         for f in field.fields:
             self.assertIsInstance(f, forms.NullBooleanField)
@@ -111,7 +111,7 @@ def widget_tests(self, form):
             # The default form field widget is expected to be MultiNullBooleanSelects.
             self.assertIsInstance(form.fields['extra_order'].widget, MultiNullBooleanSelects)
             # The choices are expected to be split into separate widgets.
-            self.assertEqual(len(form.fields['extra_order'].widget.widgets), 4)
+            self.assertLength(form.fields['extra_order'].widget.widgets, 4)
             # Widget name suffixes are expected to be the choice values.
             self.assertEqual(
                 form.fields['extra_order'].widget.widgets_names,
diff --git a/tests/forms/test_widgets.py b/tests/forms/test_widgets.py
index 9028eae4..b90e36a6 100644
--- a/tests/forms/test_widgets.py
+++ b/tests/forms/test_widgets.py
@@ -13,7 +13,7 @@
 
 from hosting.widgets import (
     ClearableWithPreviewImageInput, CustomNullBooleanSelect,
-    ExpandedMultipleChoice, InlineRadios,
+    ExpandedMultipleChoice, FormDivider, InlineRadios,
     MultiNullBooleanSelects, TextWithDatalistInput,
 )
 from maps.widgets import AdminMapboxGlWidget, MapboxGlWidget
@@ -218,7 +218,7 @@ class DummyForm(forms.Form):
 
 
 @tag('forms', 'widgets')
-class ExpandedMultipleChoiceWidgetTests(TestCase):
+class ExpandedMultipleChoiceWidgetTests(AdditionalAsserts, TestCase):
     @classmethod
     def setUpTestData(cls):
         class MultiSelects(forms.widgets.MultiWidget):
@@ -256,11 +256,11 @@ def test_render(self):
         # The form elements are expected to be rendered in a container corresponding
         # to the form's multi-value field.
         container_element = html.select('div#id_the_past_form_element')
-        self.assertEqual(len(container_element), 1)
+        self.assertLength(container_element, 1)
         self.assertNotIn("collapse", container_element[0].attrs.get('class', {}))
         self.assertNotIn('aria-expanded', container_element[0].attrs)
         # No control label is expected to be rendered by default.
-        self.assertEqual(len(html.select('label.control-label')), 0)
+        self.assertLength(html.select('label.control-label'), 0)
         for i, subfield in enumerate(form.fields['the_past'].fields, start=1):
             element_id = f'id_the_past_option_{i}_form_element'
             with self.subTest(container_id=element_id):
@@ -347,9 +347,9 @@ def test_css_classes(self):
                 # classes are expected to be in use.
                 subelement = element.find('div', id=f'id_the_past_{i-1}')
                 self.assertIsNotNone(subelement)
-                self.assertEqual(
-                    set(subelement.parent.attrs['class']),
-                    set(["controls", "checkbox"]))
+                self.assertCountEqual(
+                    subelement.parent.attrs['class'],
+                    ["controls", "checkbox"])
                 for opt in subfield.choices:
                     optelement = subelement.find(
                         'input',
@@ -389,16 +389,16 @@ def test_css_classes(self):
         self.assertEqual(container_element.attrs.get('aria-expanded'), 'false')
         # The control labels are expected to be rendered with the specified CSS class.
         label_elements = html.select('label.control-label')
-        self.assertEqual(len(label_elements), 2)
+        self.assertLength(label_elements, 2)
         for label_element in label_elements:
             self.assertIn("custom-label", label_element.attrs['class'])
         for i, subfield in enumerate(form.fields['the_past'].fields, start=1):
             # The specified subfield's CSS class is expected to be used.
             subelement = html.find('div', id=f'id_the_past_{i-1}')
             self.assertIsNotNone(subelement)
-            self.assertEqual(
-                set(subelement.parent.attrs['class']),
-                set(["custom-controls", "controls", "checkbox"]))
+            self.assertCountEqual(
+                subelement.parent.attrs['class'],
+                ["custom-controls", "controls", "checkbox"])
             for opt in subfield.choices:
                 option_element = subelement.find(
                     'input',
@@ -429,14 +429,259 @@ def test_css_classes(self):
         )
         html = BeautifulSoup(result, HTML_PARSER)
         # No control label is expected to be rendered by default.
-        self.assertEqual(len(html.select('label.control-label')), 0)
-        self.assertEqual(len(html.select('label.custom-label')), 0)
+        self.assertLength(html.select('label.control-label'), 0)
+        self.assertLength(html.select('label.custom-label'), 0)
         # Unknown values in extra rendering context are not supposed to be used.
         self.assertNotIn('inline_class', context)
         self.assertNotIn('inline_class', result)
         self.assertNotIn("select-inline", result)
 
 
+@tag('forms', 'widgets')
+class FormDividerWidgetTests(AdditionalAsserts, TestCase):
+    @classmethod
+    def setUpTestData(cls):
+        class DummyForm(forms.Form):
+            all_years = forms.IntegerField(label="All Years")
+
+        cls.DummyForm = DummyForm
+
+    def test_render(self):
+        widget = FormDivider()
+        result = widget.render(self.DummyForm(), 'default', Context({}))
+        html = BeautifulSoup(result, 'html.parser')
+        # The widget is expected to be composed of a container (with no ID)
+        # and a single element for the horizontal divider.
+        element = html.select('.form-divider')
+        self.assertLength(element, 1)
+        element = element[0]
+        self.assertNotIn('id', element.attrs)
+        self.assertEqual(element.attrs['class'], ["form-divider"])
+        subelement = element.select('.divider-heading')
+        self.assertLength(subelement, 1)
+        subelement = subelement[0]
+        self.assertLength(subelement.attrs['class'], 1)
+        # The sub-element is expected to have no content and no ARIA role.
+        self.assertNotIn('aria-role', subelement.attrs)
+        self.assertEqual(subelement.contents, [])
+        self.assertIsNone(element.find('button'))
+        # A specific keyboard tabbing index for the divider form element
+        # is not expected to be set.
+        self.assertNotIn('tabindex', result)
+
+        widget = FormDivider(title="monkeying Around")
+        for show_labels in (False, True):
+            with self.subTest(show_labels=show_labels):
+                context = Context({'form_show_labels': show_labels, 'tabindex': 3})
+                result = widget.render(
+                    self.DummyForm(), 'default', context,
+                    extra_context={'inline_label': "monkeyshines"})
+                html = BeautifulSoup(result, 'html.parser')
+                element = html.find(None, "form-divider")
+                self.assertIsNotNone(element)
+                subelement = element.find(None, "divider-heading", recursive=False)
+                self.assertIsNotNone(subelement)
+                if not show_labels:
+                    # When form labels are turned off, no text is expected to be
+                    # rendered on the horizontal divider sub-element, even if provided.
+                    # The sub-element is expected to have no ARIA role, as it is purely
+                    # decorative.
+                    self.assertLength(subelement.attrs['class'], 1)
+                    self.assertNotIn('aria-role', subelement.attrs)
+                    self.assertEqual(subelement.contents, [])
+                else:
+                    # When form labels are turned on, the given title is expected to be
+                    # rendered on the horizontal divider sub-element, and the
+                    # sub-element is expected to have the suitable ARIA role.
+                    self.assertIn("has-content", subelement.attrs['class'])
+                    self.assertEqual(subelement.attrs.get('aria-role'), 'separator')
+                    self.assertEqual(subelement.string, "monkeying Around")
+                # A specific keyboard tabbing index for the divider form element is not
+                # expected to be set (the element is expected to be unreachable by the
+                # keyboard).
+                self.assertNotIn('tabindex', result)
+                # Unknown values in extra rendering context are not supposed to be used.
+                self.assertNotIn('inline_label', context)
+                self.assertNotIn('inline_label', result)
+                self.assertNotIn("monkeyshines", result)
+
+    def test_css_class(self):
+        widget = FormDivider(wrapper_class="my-container")
+        result = widget.render(self.DummyForm(), 'default', Context({}))
+        html = BeautifulSoup(result, 'html.parser')
+        element = html.select('.my-container')
+        self.assertLength(element, 1)
+        # The given wrapping class is expected for the container element.
+        self.assertCountEqual(element[0].attrs['class'], ["form-divider", "my-container"])
+
+    def switch_rendering_tests(
+            self, render_output, lang,
+            *, expected_field_id, expected_label, collapsed, tabindex=None,
+    ):
+        html = BeautifulSoup(render_output, 'html.parser')
+
+        # The widget which has a collapsing control enabled is expected
+        # to be composed of a container inside of which a switch button
+        # controlling the folding of the other form element and an
+        # element for the horizontal divider.
+        element = html.find(None, "form-divider")
+        self.assertIsNotNone(element)
+        switch_element = element.find('button', recursive=False)
+        self.assertIsNotNone(switch_element)
+        self.assertEqual(switch_element.attrs.get('id'), f'{expected_field_id}_switch')
+        # The switch button is expected to have the default CSS classes.
+        self.assertIn("switch", switch_element.attrs['class'])
+        self.assertIn("btn", switch_element.attrs['class'])
+        self.assertIn("btn-sm", switch_element.attrs['class'])
+        if tabindex is None:
+            # When no explicit keyboard tabbing index is specified, it is
+            # expected to not be set for the switch button.
+            self.assertNotIn('tabindex', switch_element.attrs)
+        else:
+            # When a keyboard tabbing index is specified, it is expected
+            # to be set for the switch button.
+            self.assertIn('tabindex', switch_element.attrs)
+            self.assertEqual(switch_element.attrs['tabindex'], str(tabindex))
+        # The switch button is expected to control the given form element.
+        self.assertEqual(
+            switch_element.attrs.get('aria-controls'),
+            f'{expected_field_id}_form_element'
+        )
+
+        switch_icon_element = switch_element.find(None, "fa", recursive=False)
+        self.assertIsNotNone(switch_icon_element)
+        # The switch button is expected to indicate the ARIA 'expanded'
+        # state of the other form element according to the initial mode.
+        self.assertEqual(
+            switch_element.attrs.get('aria-expanded'),
+            'false' if collapsed else 'true'
+        )
+        self.assertIn("fa-caret-right", switch_icon_element.attrs['class'])
+        if not collapsed:
+            # A visual indicator of the 'expanded' state is expected on
+            # the switch button.
+            self.assertIn("fa-rotate-90", switch_icon_element.attrs['class'])
+
+        # The switch button is expected to have a suitable ARIA label.
+        label_show = {
+            'en': f"{expected_label}: Show" if expected_label else "Show",
+            'eo': f"{expected_label}: Montri" if expected_label else "Montri",
+        }
+        label_hide = {
+            'en': f"{expected_label}: Hide" if expected_label else "Hide",
+            'eo': f"{expected_label}: Kaŝi" if expected_label else "Kaŝi",
+        }
+        self.assertEqual(
+            safe_trim(switch_icon_element.attrs.get('aria-label')),
+            label_show[lang].strip() if collapsed else label_hide[lang].strip()
+        )
+        self.assertEqual(
+            safe_trim(switch_icon_element.attrs.get('data-aria-label-inactive')),
+            label_hide[lang].strip() if collapsed else label_show[lang].strip()
+        )
+
+        # The switch button is expected to be followed by the horizontal
+        # divider element.
+        divider_element = switch_element.find_next_sibling(None, "divider-heading")
+        self.assertIsNotNone(divider_element)
+
+    def test_render_switch_for_field_name(self):
+        # When the collapsible form element is indicated by the corresponding
+        # form field's name, which is not among the form's fields, a KeyError
+        # exception is expected and no widget rendered.
+        with self.assertRaises(KeyError):
+            widget = FormDivider(collapse_field_name='first_year')
+            widget.render(self.DummyForm(), 'default', Context({}))
+
+        for initially_collapsed in (None, False, True):
+            with self.subTest(collapsed=initially_collapsed):
+                with self.assertNotRaises(KeyError):
+                    widget = FormDivider(
+                        title="monKey",
+                        collapse_field_name='all_years', collapse_field_label="Lui",
+                        collapsed=initially_collapsed)
+                    for lang in ['en', 'eo']:
+                        with self.subTest(lang=lang):
+                            with override_settings(LANGUAGE_CODE=lang):
+                                result = widget.render(
+                                    self.DummyForm(), 'default', Context({}))
+                            # The switch button is expected to control the form element
+                            # identified by the ID of the given form field and the
+                            # actual form field's label is expected to override the
+                            # custom label given to the widget.
+                            self.switch_rendering_tests(
+                                result, lang, collapsed=initially_collapsed,
+                                expected_field_id='id_all_years', expected_label="All Years")
+
+    def test_render_switch_for_field_id(self):
+        for initially_collapsed in (None, False, True):
+            with self.subTest(collapsed=initially_collapsed):
+                # Explicit form field ID is expected to take preference over the field
+                # name, if both are given.
+                with self.assertNotRaises(KeyError):
+                    widget = FormDivider(
+                        collapse_field_name='future_years',
+                        collapse_field_id='id_other_years', collapse_field_label="Lui",
+                        collapsed=initially_collapsed)
+                    for lang in ['en', 'eo']:
+                        with self.subTest(lang=lang):
+                            with override_settings(LANGUAGE_CODE=lang):
+                                result = widget.render(
+                                    self.DummyForm(), 'default', Context({}))
+                            # The switch button is expected to control the form element
+                            # identified by the given ID (even if a form field name is
+                            # also given) and the given custom label is expected to be
+                            # used in all cases.
+                            self.switch_rendering_tests(
+                                result, lang, collapsed=initially_collapsed,
+                                expected_field_id='id_other_years', expected_label="Lui")
+
+        # If a custom field label is given (alongside a specific element
+        # ID) it is expected to be used on the switch button; otherwise,
+        # if a title is given, it is expected to be used. If none of these
+        # two are given, the ARIA label of the switch button is expected
+        # to be the default one corresponding to the element's 'expanded'
+        # state.
+        for title in ("monKey", " ", None):
+            for custom_label in ("Lui", " ", None):
+                with self.subTest(
+                        has_title=title is not None,
+                        field_has_label=custom_label is not None,
+                ):
+                    widget = FormDivider(
+                        title=title,
+                        collapse_field_name='all_years',
+                        collapse_field_id='id_other_years', collapse_field_label=custom_label,
+                    )
+                    for lang in ['en', 'eo']:
+                        with self.subTest(lang=lang):
+                            with override_settings(LANGUAGE_CODE=lang):
+                                result = widget.render(
+                                    self.DummyForm(), 'default', Context({'tabindex': 5}))
+                            # The switch button is expected to control the form element
+                            # identified by the given ID and to be reachable via the
+                            # given keyboard tabbing index.
+                            self.switch_rendering_tests(
+                                result, lang, collapsed=None, tabindex=5,
+                                expected_field_id='id_other_years',
+                                expected_label=custom_label or title or None)
+
+    def test_switch_css_class(self):
+        widget = FormDivider(switch_button_class="danger btn-lg", collapse_field_id='id_test')
+        result = widget.render(self.DummyForm(), 'default', Context({}))
+        html = BeautifulSoup(result, 'html.parser')
+        element = html.find(None, "form-divider")
+        self.assertIsNotNone(element)
+        switch_element = element.find('button', recursive=False)
+        self.assertIsNotNone(switch_element)
+        self.assertIn("switch", switch_element.attrs['class'])
+        # The given CSS classes are expected for the switch button.
+        self.assertIn("btn-lg", switch_element.attrs['class'])
+        self.assertIn("danger", switch_element.attrs['class'])
+        # The default CSS class is expected to be not present on the button.
+        self.assertNotIn("btn-sm", switch_element.attrs['class'])
+
+
 @tag('forms', 'widgets')
 class MapboxGlWidgetTests(AdditionalAsserts, TestCase):
     widget_class = MapboxGlWidget
@@ -473,7 +718,7 @@ def test_render(self):
             # The template fragment is expected to include the container for the dynamic map.
             map_container_element = dom_tree.find('div', id='map')
             self.assertIsNotNone(map_container_element)
-            self.assertEqual(len(map_container_element.contents), 0)
+            self.assertLength(map_container_element.contents, 0)
             # The template fragment is expected to include a fallback for no JavaScript.
             noscript_element = dom_tree.find('noscript')
             self.assertIsNotNone(noscript_element)

From e540d9f755ff8671743df82da7ea360e8a64fc91 Mon Sep 17 00:00:00 2001
From: Meir <interDist@users.noreply.github.com>
Date: Sat, 12 Aug 2023 09:34:31 +0200
Subject: [PATCH 4/4] =?UTF-8?q?korektas=20indeksadon=20de=20objektoj=20For?=
 =?UTF-8?q?m=20Layout=20por=20lo=C4=9Deja=20formularo?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 hosting/forms/places.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/hosting/forms/places.py b/hosting/forms/places.py
index ad77e779..7ebb74a6 100644
--- a/hosting/forms/places.py
+++ b/hosting/forms/places.py
@@ -86,7 +86,7 @@ def __init__(self, *args, **kwargs):
         self.helper = FormHelper(self)
         self.fields['state_province'].widget.attrs['autocomplete'] = 'region'
         # Combine the postcode and the city fields together in one line.
-        postcode_field_index = self._meta.fields.index('postcode')
+        postcode_field_index = self.helper.layout.fields.index('postcode')
         self.helper[postcode_field_index:postcode_field_index+2].wrap_together(Div, css_class='row')
         self.helper['postcode'].wrap(Field, wrapper_class='col-xxs-12 col-xs-4')
         self.helper['city'].wrap(Field, wrapper_class='col-xxs-12 col-xs-8')
@@ -97,9 +97,9 @@ def __init__(self, *args, **kwargs):
         self.fields['address'].widget.attrs['autocomplete'] = 'street-address'
         # Split address details from the description and conditions.
         self.helper.layout.insert(self.helper.layout.fields.index('max_guest'), FormDivider())
-        # Combine the count fields together in one line (index is shifted because of postcode+city layout change).
-        max_guests_field_index = self._meta.fields.index('max_guest')
-        self.helper[max_guests_field_index-1:max_guests_field_index+2].wrap_together(Div, css_class='row')
+        # Combine the count fields together in one line.
+        max_guests_field_index = self.helper.layout.fields.index('max_guest')
+        self.helper[max_guests_field_index:max_guests_field_index+3].wrap_together(Div, css_class='row')
         for field, field_icon in {'max_guest': 'fa-street-view', 'max_night': 'fa-regular fa-moon'}.items():
             self.helper[field].wrap(
                 PrependedText,