edits

Author: timgraham

django_mongodb_backend/forms/fields/multiple_embedded_model.py

@@ -1,45 +1,49 @@
 from django import forms
 from django.core.exceptions import ValidationError
-from django.db.models import Model
 from django.forms import formset_factory, model_to_dict
 from django.forms.models import modelform_factory
 from django.utils.html import format_html, format_html_join
-from django.utils.translation import gettext_lazy as _
 
 
-class MultipleEmbeddedModelFormField(forms.Field):
-    default_error_messages = {"incomplete": _("Enter all required values.")}
+def models_to_dicts(models):
+    """
+    Convert initial data (which is a list of model instances or None) to a
+    list of dictionary data suitable for a formset.
+    """
+    return [model_to_dict(model) for model in models or []]
+
 
+class MultipleEmbeddedModelFormField(forms.Field):
     def __init__(self, model, prefix, max_length=None, *args, **kwargs):
         kwargs.pop("base_field")
         self.model = model
         self.prefix = prefix
-        self.model_form_cls = modelform_factory(model, fields="__all__")
         self.formset = formset_factory(
-            form=self.model_form_cls, can_delete=True, max_num=max_length
+            form=modelform_factory(model, fields="__all__"),
+            can_delete=True,
+            max_num=max_length,
         )
-        kwargs["widget"] = MultipleEmbeddedModelWidget(self.model_form_cls.__name__)
+        kwargs["widget"] = MultipleEmbeddedModelWidget()
         super().__init__(*args, **kwargs)
 
     def clean(self, value):
         if not value:
+            # TODO: null or empty list?
             return []
         formset = self.formset(value, prefix=self.prefix)
         if not formset.is_valid():
-            raise ValidationError(formset.errors + formset.non_form_errors())
+            raise ValidationError(formset.errors)
         cleaned_data = []
         for data in formset.cleaned_data:
+            # The fallback to True skips empty forms.
             if data.get("DELETE", True):
                 continue
-            data.pop("DELETE")
-            cleaned_data.append(self.model_form_cls._meta.model(**data))
+            data.pop("DELETE")  # The "delete" checkbox isn't part of model data.
+            cleaned_data.append(self.model(**data))
         return cleaned_data
 
     def has_changed(self, initial, data):
-        formset_initial = []
-        for initial_data in initial or []:
-            formset_initial.append(forms.model_to_dict(initial_data))
-        formset = self.formset(data, initial=formset_initial, prefix=self.prefix)
+        formset = self.formset(data, initial=models_to_dicts(initial), prefix=self.prefix)
         return formset.has_changed()
 
     def get_bound_field(self, form, field_name):
@@ -49,46 +53,24 @@ def get_bound_field(self, form, field_name):
 class MultipleEmbeddedModelBoundField(forms.BoundField):
     def __init__(self, form, field, name):
         super().__init__(form, field, name)
-        data = self.data if form.is_bound else None
-        formset_initial = []
-        if self.initial is not None:
-            for initial in self.initial:
-                if isinstance(initial, Model):
-                    formset_initial.append(model_to_dict(initial))
-        self.formset = field.formset(data, initial=formset_initial, prefix=self.html_name)
-
-    def __getitem__(self, idx):
-        if not isinstance(idx, (int | slice)):
-            raise TypeError
-        return self.formset[idx]
-
-    def __iter__(self):
-        yield from self.formset
+        self.formset = field.formset(
+            self.data if form.is_bound else None,
+            initial=models_to_dicts(self.initial),
+            prefix=self.html_name,
+        )
 
     def __str__(self):
-        table = format_html_join(
+        body = format_html_join(
             "\n", "<tbody>{}</tbody>", ((form.as_table(),) for form in self.formset)
         )
-        table = format_html("\n<table>" "\n{}" "\n</table>", table)
-        return format_html("{}\n{}", table, self.formset.management_form)
-
-    def __len__(self):
-        return len(self.formset)
+        return format_html("<table>\n{}\n</table>\n{}", body, self.formset.management_form)
 
 
 class MultipleEmbeddedModelWidget(forms.Widget):
-    def __init__(self, field_id, attrs=None):
-        self.field_id = field_id
-        super().__init__(attrs)
-
-    def render(self, name, value, attrs=None, renderer=None):
-        raise NotImplementedError("This widget is not meant to be rendered.")
-
-    def id_for_label(self, id_):
-        return f"{id_}-0-{self.field_id}"
+    """
+    This widget extracts the data for MultipleEmbeddedModelFormField's formset.
+    It is never rendered.
+    """
 
     def value_from_datadict(self, data, files, name):
-        return {key: data[key] for key in data if key.startswith(name)}
-
-    def value_omitted_from_data(self, data, files, name):
-        return any(key.startswith(name) for key in data)
+        return {key: data[key] for key in data if key.startswith(f"{name}-")}

tests/model_forms_/models.py

@@ -38,7 +38,8 @@ def __str__(self):
 
 class Movie(models.Model):
     title = models.CharField(max_length=255)
-    reviews = MultipleEmbeddedModelField(Review, null=True)
+    reviews = MultipleEmbeddedModelField(Review)
+    featured_reviews = MultipleEmbeddedModelField(Review, null=True, blank=True)
 
     def __str__(self):
         return self.title

tests/model_forms_/test_multiple_embedded_model.py

@@ -32,6 +32,28 @@ def test_add_another(self):
         self.assertEqual(review.title, "Not so great")
         self.assertEqual(review.rating, 1)
 
+    def test_no_change(self):
+        movie = Movie.objects.create(
+            title="Lion King",
+            reviews=[Review(title="Great!", rating=10)],
+        )
+        data = {
+            "title": "Lion King",
+            "reviews-0-title": "Great!",
+            "reviews-0-rating": "10",
+            "reviews-TOTAL_FORMS": 2,
+            "reviews-INITIAL_FORMS": 1,
+        }
+        form = MovieForm(data, instance=movie)
+        self.assertTrue(form.is_valid())
+        form.save()
+        self.assertEqual(form.changed_data, [])
+        movie.refresh_from_db()
+        self.assertEqual(len(movie.reviews), 1)
+        review = movie.reviews[0]
+        self.assertEqual(review.title, "Great!")
+        self.assertEqual(review.rating, 10)
+
     def test_update(self):
         movie = Movie.objects.create(
             title="Lion King",
@@ -47,6 +69,7 @@ def test_update(self):
         form = MovieForm(data, instance=movie)
         self.assertTrue(form.is_valid())
         form.save()
+        self.assertEqual(form.changed_data, ["reviews"])
         movie.refresh_from_db()
         self.assertEqual(len(movie.reviews), 1)
         review = movie.reviews[0]
@@ -149,34 +172,38 @@ def test_delete_required(self):
         self.assertFalse(form.is_valid())
         self.assertEqual(form.errors["reviews"], ["This field cannot be blank."])
 
-    #    def test_nullable_field(self):
-    #        """A nullable EmbeddedModelField is removed if all fields are empty."""
-    #        author = Author.objects.create(
-    #            name="Bob",
-    #            age=50,
-    #            address=Address(city="NYC", state="NY", zip_code="10001"),
-    #            billing_address=Address(city="NYC", state="NY", zip_code="10001"),
-    #        )
-    #        data = {
-    #            "name": "Bob",
-    #            "age": 51,
-    #            "address-po_box": "",
-    #            "address-city": "New York City",
-    #            "address-state": "NY",
-    #            "address-zip_code": "10001",
-    #            "billing_address-po_box": "",
-    #            "billing_address-city": "",
-    #            "billing_address-state": "",
-    #            "billing_address-zip_code": "",
-    #        }
-    #        form = AuthorForm(data, instance=author)
-    #        self.assertTrue(form.is_valid())
-    #        form.save()
-    #        author.refresh_from_db()
-    #        self.assertIsNone(author.billing_address)
+    def test_nullable_field(self):
+        """A nullable field is emptied if all rows are deleted."""
+        movie = Movie.objects.create(
+            title="Lion King",
+            reviews=[Review(title="Great!", rating=10)],
+            featured_reviews=[Review(title="Okay", rating=5)],
+        )
+        data = {
+            "title": "Lion King",
+            "reviews-0-title": "Not so great",
+            "reviews-0-rating": "1",
+            "reviews-0-DELETE": "",
+            "reviews-TOTAL_FORMS": 2,
+            "reviews-INITIAL_FORMS": 1,
+            "featured-reviews-0-title": "Okay",
+            "featured-reviews-0-rating": "5",
+            "featured-reviews-0-DELETE": "1",
+            "featured-reviews-TOTAL_FORMS": 2,
+            "featured-reviews-INITIAL_FORMS": 1,
+        }
+        form = MovieForm(data, instance=movie)
+        self.assertTrue(form.is_valid())
+        form.save()
+        movie.refresh_from_db()
+        self.assertEqual(len(movie.featured_reviews), 0)
 
     def test_rendering(self):
         form = MovieForm()
+        self.assertHTMLEqual(
+            str(form.fields["reviews"].get_bound_field(form, "reviews").label_tag()),
+            '<label for="id_reviews">Reviews:</label>',
+        )
         self.assertHTMLEqual(
             str(form.fields["reviews"].get_bound_field(form, "reviews")),
             """
@@ -209,6 +236,64 @@ def test_rendering(self):
                 name="reviews-MAX_NUM_FORMS" value="1000" id="id_reviews-MAX_NUM_FORMS">""",
         )
 
+    def test_rendering_initial(self):
+        movie = Movie.objects.create(
+            title="Lion King",
+            reviews=[Review(title="Great!", rating=10)],
+        )
+        form = MovieForm(instance=movie)
+        self.assertHTMLEqual(
+            str(form.fields["reviews"].get_bound_field(form, "reviews")),
+            """
+            <table>
+            <tbody><tr>
+                <th><label for="id_reviews-0-title">Title:</label></th>
+                <td>
+                  <input type="text" name="reviews-0-title" maxlength="255"
+                    id="id_reviews-0-title" value="Great!">
+                </td>
+              </tr>
+              <tr>
+                <th><label for="id_reviews-0-rating">Rating:</label></th>
+                <td>
+                  <input type="number" name="reviews-0-rating"
+                    id="id_reviews-0-rating" value="10">
+                </td>
+              </tr>
+              <tr>
+                <th><label for="id_reviews-0-DELETE">Delete:</label></th>
+                <td>
+                  <input type="checkbox" name="reviews-0-DELETE" id="id_reviews-0-DELETE">
+                </td>
+              </tr></tbody>
+            <tbody><tr>
+                <th><label for="id_reviews-1-title">Title:</label></th>
+                <td>
+                  <input type="text" name="reviews-1-title" maxlength="255" id="id_reviews-1-title">
+                </td>
+              </tr>
+              <tr>
+                <th><label for="id_reviews-1-rating">Rating:</label></th>
+                <td>
+                  <input type="number" name="reviews-1-rating" id="id_reviews-1-rating">
+                </td>
+              </tr>
+              <tr>
+                <th><label for="id_reviews-1-DELETE">Delete:</label></th>
+                <td>
+                  <input type="checkbox" name="reviews-1-DELETE" id="id_reviews-1-DELETE">
+                </td>
+              </tr></tbody>
+            </table>
+            <input type="hidden" name="reviews-TOTAL_FORMS" value="2"
+                id="id_reviews-TOTAL_FORMS"><input type="hidden"
+                name="reviews-INITIAL_FORMS" value="1"
+                id="id_reviews-INITIAL_FORMS">
+            <input type="hidden" name="reviews-MIN_NUM_FORMS" value="0"
+                id="id_reviews-MIN_NUM_FORMS"><input type="hidden"
+                name="reviews-MAX_NUM_FORMS" value="1000" id="id_reviews-MAX_NUM_FORMS">""",
+        )
+
 
 # class NestedFormTests(TestCase):
 #    def test_update(self):