Add method get_attribute_values to Product model which also fetches parent product attributes (#3514)

docs/source/releases/v3.0.rst

 
 - Category slugs can now be edited via the dashboard.
 
+- A new method get_attribute_values() was added to the Product model which returns a merged set of attribute values for child and parent products.
+
 Dependency changes
 ~~~~~~~~~~~~~~~~~~
 

src/oscar/apps/catalogue/abstract_models.py

         """
         Return a string of all of a product's attributes
         """
-        attributes = self.attribute_values.all()
+        attributes = self.get_attribute_values()
         pairs = [attribute.summary() for attribute in attributes]
         return ", ".join(pairs)
 
             return self.categories
     get_categories.short_description = _("Categories")
 
+    def get_attribute_values(self):
+        attribute_values = self.attribute_values.all()
+        if self.is_child:
+            parent_attribute_values = self.parent.attribute_values.exclude(
+                attribute__code__in=attribute_values.values("attribute__code")
+            )
+            return attribute_values | parent_attribute_values
+
+        return attribute_values
+
     # Images
 
     def get_missing_image(self):

src/oscar/apps/catalogue/product_attributes.py

                         {'attr': attribute.code, 'err': e})
 
     def get_values(self):
-        return self.product.attribute_values.all()
+        return self.product.get_attribute_values()
 
     def get_value_by_attribute(self, attribute):
         return self.get_values().get(attribute=attribute)

src/oscar/apps/shipping/scales.py

     def weigh_product(self, product):
         weight = None
         try:
-            weight = product.attribute_values.get(
+            weight = product.get_attribute_values().get(
                 attribute__code=self.attribute).value
         except ObjectDoesNotExist:
-            if product.parent:
-                try:
-                    weight = product.parent.attribute_values.get(
-                        attribute__code=self.attribute).value
-                except ObjectDoesNotExist:
-                    pass
+            pass
 
         if weight is None:
             if self.default_weight is None:

src/oscar/templates/oscar/catalogue/detail.html

                 <td>{{ session.availability.message }}</td>
             </tr>
         {% endif %}
-        {% for av in product.attribute_values.all %}
+        {% for av in product.get_attribute_values %}
             <tr>
                 <th>{{ av.attribute.name }}</th>
                 <td>{{ av.value_as_html }}</td>

tests/integration/catalogue/test_product.py

             product_class=self.product_class,
             structure=Product.PARENT,
             is_discountable=False)
+        ProductAttribute.objects.create(
+            product_class=self.product_class,
+            name='The first attribute',
+            code='first_attribute',
+            type='text')
+        ProductAttribute.objects.create(
+            product_class=self.product_class,
+            name='The second attribute',
+            code='second_attribute',
+            type='text')
 
     def test_child_products_dont_need_titles(self):
         Product.objects.create(
             structure=Product.CHILD)
         self.assertEqual(set([self.parent]), set(Product.objects.browsable()))
 
+    def test_child_products_attribute_values(self):
+        product = Product.objects.create(
+            product_class=self.product_class, parent=self.parent,
+            structure=Product.CHILD)
+
+        self.parent.attr.first_attribute = "klats"
+        product.attr.second_attribute = "henk"
+        self.parent.save()
+        product.save()
+
+        product = Product.objects.get(pk=product.pk)
+        parent = Product.objects.get(pk=self.parent.pk)
+
+        self.assertEqual(parent.get_attribute_values().count(), 1)
+        self.assertEqual(product.get_attribute_values().count(), 2)
+        self.assertTrue(hasattr(parent.attr, "first_attribute"))
+        self.assertFalse(hasattr(parent.attr, "second_attribute"))
+        self.assertTrue(hasattr(product.attr, "first_attribute"))
+        self.assertTrue(hasattr(product.attr, "second_attribute"))
+
+    def test_child_products_attribute_values_no_parent_values(self):
+        product = Product.objects.create(
+            product_class=self.product_class, parent=self.parent,
+            structure=Product.CHILD)
+
+        product.attr.second_attribute = "henk"
+        product.save()
+
+        product = Product.objects.get(pk=product.pk)
+
+        self.assertEqual(self.parent.get_attribute_values().count(), 0)
+        self.assertEqual(product.get_attribute_values().count(), 1)
+        self.assertFalse(hasattr(self.parent.attr, "first_attribute"))
+        self.assertFalse(hasattr(self.parent.attr, "second_attribute"))
+        self.assertFalse(hasattr(product.attr, "first_attribute"))
+        self.assertTrue(hasattr(product.attr, "second_attribute"))
+
 
 class TestAChildProduct(TestCase):