Add new type field for product.Option and enhanced form rendering for options based on their type.

docs/source/releases/v3.0.rst

@@ -21,6 +21,17 @@ Compatibility
 What's new in Oscar 3.0?
 ~~~~~~~~~~~~~~~~~~~~~~~~
 
+- Support has been added to the ``catalogue.Option`` model to define the
+  type of option. This is used by the ``AddToBasketForm`` to determine the appropriate form field to display for that
+  option in the add-to-cart form. Currently supported types are: text, integer, float, boolean, and date.
+
+  The ``type`` field on the ``Option`` model (previously used to denote whether the option is required)
+  has been repurposed to store the type of the option, and a new ``required`` field
+  has been added to denote whether the option is required. Projects that have forked the catalogue app will
+  need to generate custom migrations for these model field changes.
+  Projects should pay close attention to the data migration provided in
+  ``catalogue/migrations/0019_option_required.py`` for this change.
+
 
 Backwards incompatible changes
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

src/oscar/apps/basket/forms.py

@@ -9,10 +9,32 @@ from oscar.forms import widgets
 
 Line = get_model('basket', 'line')
 Basket = get_model('basket', 'basket')
+Option = get_model('catalogue', 'option')
 Product = get_model('catalogue', 'product')
 
 
+def _option_text_field(option):
+    return forms.CharField(label=option.name, required=option.required)
+
+
+def _option_integer_field(option):
+    return forms.IntegerField(label=option.name, required=option.required)
+
+
+def _option_boolean_field(option):
+    return forms.BooleanField(label=option.name, required=option.required)
+
+
+def _option_float_field(option):
+    return forms.FloatField(label=option.name, required=option.required)
+
+
+def _option_date_field(option):
+    return forms.DateField(label=option.name, required=option.required, widget=forms.widgets.DateInput)
+
+
 class BasketLineForm(forms.ModelForm):
+
     save_for_later = forms.BooleanField(
         initial=False, required=False, label=_('Save for Later'))
 
@@ -120,6 +142,15 @@ class BasketVoucherForm(forms.Form):
 
 
 class AddToBasketForm(forms.Form):
+
+    OPTION_FIELD_FACTORIES = {
+        Option.TEXT: _option_text_field,
+        Option.INTEGER: _option_integer_field,
+        Option.BOOLEAN: _option_boolean_field,
+        Option.FLOAT: _option_float_field,
+        Option.DATE: _option_date_field,
+    }
+
     quantity = forms.IntegerField(initial=1, min_value=1, label=_('Quantity'))
 
     def __init__(self, basket, product, *args, **kwargs):
@@ -182,8 +213,8 @@ class AddToBasketForm(forms.Form):
         This is designed to be overridden so that specific widgets can be used
         for certain types of options.
         """
-        self.fields[option.code] = forms.CharField(
-            label=option.name, required=option.is_required)
+        option_field = self.OPTION_FIELD_FACTORIES.get(option.type, Option.TEXT)(option)
+        self.fields[option.code] = option_field
 
     # Cleaning
 

src/oscar/apps/catalogue/abstract_models.py

@@ -23,6 +23,7 @@ from django.utils.translation import gettext_lazy as _
 from django.utils.translation import pgettext_lazy
 from treebeard.mp_tree import MP_Node
 
+from oscar.core.decorators import deprecated
 from oscar.core.loading import get_class, get_classes, get_model
 from oscar.core.utils import slugify
 from oscar.core.validators import non_python_keyword
@@ -1180,18 +1181,31 @@ class AbstractOption(models.Model):
     This is not the same as an 'attribute' as options do not have a fixed value
     for a particular item.  Instead, option need to be specified by a customer
     when they add the item to their basket.
+
+    The `type` of the option determines the form input that will be used to
+    collect the information from the customer, and the `required` attribute
+    determines whether a value must be supplied in order to add the item to the basket.
     """
-    name = models.CharField(_("Name"), max_length=128)
-    code = AutoSlugField(_("Code"), max_length=128, unique=True,
-                         populate_from='name')
 
-    REQUIRED, OPTIONAL = ('Required', 'Optional')
+    # Option types
+    TEXT = "text"
+    INTEGER = "integer"
+    FLOAT = "float"
+    BOOLEAN = "boolean"
+    DATE = "date"
+
     TYPE_CHOICES = (
-        (REQUIRED, _("Required - a value for this option must be specified")),
-        (OPTIONAL, _("Optional - a value for this option can be omitted")),
+        (TEXT, _("Text")),
+        (INTEGER, _("Integer")),
+        (BOOLEAN, _("True / False")),
+        (FLOAT, _("Float")),
+        (DATE, _("Date")),
     )
-    type = models.CharField(_("Status"), max_length=128, default=REQUIRED,
-                            choices=TYPE_CHOICES)
+
+    name = models.CharField(_("Name"), max_length=128)
+    code = AutoSlugField(_("Code"), max_length=128, unique=True, populate_from='name')
+    type = models.CharField(_("Type"), max_length=255, default=TEXT, choices=TYPE_CHOICES)
+    required = models.BooleanField(_("Is this option required?"), default=False)
 
     class Meta:
         abstract = True
@@ -1203,8 +1217,9 @@ class AbstractOption(models.Model):
         return self.name
 
     @property
+    @deprecated
     def is_required(self):
-        return self.type == self.REQUIRED
+        return self.required
 
 
 class MissingProductImage(object):

src/oscar/apps/catalogue/migrations/0019_option_required.py

@@ -0,0 +1,37 @@
+# Generated by Django 2.1 on 2019-06-17 17:42
+
+from django.db import migrations, models
+
+
+def migrate_product_options(apps, schema_editor):
+    """
+    Migrate product Option.type field to required
+    Set Option.type='text'
+    """
+    Option = apps.get_model('catalogue', 'Option')
+    for option in Option.objects.all():
+        if option.type == "Required":
+            option.required = True
+        option.type = 'text'
+        option.save()
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('catalogue', '0018_auto_20191220_0920'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='option',
+            name='required',
+            field=models.BooleanField(default=False, verbose_name='Is option required?'),
+        ),
+        migrations.RunPython(migrate_product_options, migrations.RunPython.noop),
+        migrations.AlterField(
+            model_name='option',
+            name='type',
+            field=models.CharField(choices=[('text', 'Text'), ('integer', 'Integer'), ('boolean', 'True / False'), ('float', 'Float'), ('date', 'Date')], default='text', max_length=255, verbose_name='Type'),
+        ),
+    ]

src/oscar/apps/dashboard/catalogue/forms.py

@@ -393,4 +393,4 @@ class OptionForm(forms.ModelForm):
 
     class Meta:
         model = Option
-        fields = ['name', 'type']
+        fields = ['name', 'type', 'required']

src/oscar/apps/dashboard/catalogue/tables.py

@@ -113,6 +113,6 @@ class OptionTable(DashboardTable):
 
     class Meta(DashboardTable.Meta):
         model = Option
-        fields = ('name', 'type')
-        sequence = ('name', 'type', 'actions')
+        fields = ('name', 'type', 'required')
+        sequence = ('name', 'type', 'required', 'actions')
         per_page = settings.OSCAR_DASHBOARD_ITEMS_PER_PAGE

src/oscar/templates/oscar/partials/form_field.html

@@ -22,12 +22,12 @@
             {% endblock %}
 
             {% block controls %}
-                <div class="{% if style|default:"stacked" != 'stacked' %}col-sm-7{% endif %}">
+                <div class="{% if style|default:"stacked" != 'stacked' %}col-sm-7{% endif %}{% if field.widget_type == 'CheckboxInput' %} checkbox{% endif %}">
                     {% block widget %}
                         {% if field.widget_type == 'CheckboxInput' %}
-                            <label for="{{ field.auto_id }}" class="checkbox {% if field.field.required %}required{% endif %}">
-                                {{ field.label|safe }}
-                                {% render_field field class+="form-control" %}
+                            <label for="{{ field.auto_id }}" {% if field.field.required %}class="required"{% endif %}>
+                                {% render_field field %}
+                                {{ field.label|safe }}{% if field.field.required %} <span>*</span>{% endif %}
                             </label>
                         {% else %}
                             {% render_field field class+="form-control" %}

src/oscar/test/factories/catalogue.py

@@ -70,7 +70,8 @@ class OptionFactory(factory.DjangoModelFactory):
 
     name = 'example option'
     code = 'example'
-    type = Meta.model.OPTIONAL
+    type = Meta.model.TEXT
+    required = False
 
 
 class AttributeOptionFactory(factory.DjangoModelFactory):

tests/_site/apps/catalogue/migrations/0019_option_required.py

@@ -0,0 +1,37 @@
+# Generated by Django 2.1 on 2019-06-17 17:42
+
+from django.db import migrations, models
+
+
+def migrate_product_options(apps, schema_editor):
+    """
+    Migrate product Option.type field to required
+    Set Option.type='text'
+    """
+    Option = apps.get_model('catalogue', 'Option')
+    for option in Option.objects.all():
+        if option.type == "Required":
+            option.required = True
+        option.type = 'text'
+        option.save()
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('catalogue', '0018_auto_20191220_0920'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='option',
+            name='required',
+            field=models.BooleanField(default=False, verbose_name='Is option required?'),
+        ),
+        migrations.RunPython(migrate_product_options, migrations.RunPython.noop),
+        migrations.AlterField(
+            model_name='option',
+            name='type',
+            field=models.CharField(choices=[('text', 'Text'), ('integer', 'Integer'), ('boolean', 'True / False'), ('float', 'Float'), ('date', 'Date')], default='text', max_length=255, verbose_name='Type'),
+        ),
+    ]

tests/integration/basket/test_forms.py

@@ -10,9 +10,11 @@ from oscar.core.loading import get_model
 from oscar.test import factories
 from oscar.test.basket import add_product
 from oscar.test.factories import (
-    BenefitFactory, ConditionalOfferFactory, ConditionFactory, RangeFactory)
+    BenefitFactory, ConditionalOfferFactory, ConditionFactory,
+    OptionFactory, RangeFactory)
 
 Line = get_model('basket', 'Line')
+Option = get_model('catalogue', 'Option')
 
 
 class TestBasketLineForm(TestCase):
@@ -205,3 +207,80 @@ class TestAddToBasketForm(TestCase):
             'This product cannot be added to the basket because a price '
             'could not be determined for it.',
         )
+
+
+class TestAddToBasketWithOptionForm(TestCase):
+
+    def setUp(self):
+        self.basket = factories.create_basket(empty=True)
+        self.product = factories.create_product(num_in_stock=1)
+
+    def _get_basket_form(self, basket, product, data=None):
+        return forms.AddToBasketForm(basket=basket, product=product, data=data)
+
+    def test_basket_option_field_exists(self):
+        option = OptionFactory()
+        self.product.product_class.options.add(option)
+        form = self._get_basket_form(basket=self.basket, product=self.product)
+        self.assertIn(option.code, form.fields)
+
+    def test_add_to_basket_with_not_required_option(self):
+        option = OptionFactory(required=False)
+        self.product.product_class.options.add(option)
+        data = {'quantity': 1}
+        form = self._get_basket_form(
+            basket=self.basket, product=self.product, data=data,
+        )
+        self.assertTrue(form.is_valid())
+        self.assertFalse(form.fields[option.code].required)
+
+    def test_add_to_basket_with_required_option(self):
+        option = OptionFactory(required=True)
+        self.product.product_class.options.add(option)
+        data = {'quantity': 1}
+        invalid_form = self._get_basket_form(
+            basket=self.basket, product=self.product, data=data,
+        )
+        self.assertFalse(invalid_form.is_valid())
+        self.assertTrue(invalid_form.fields[option.code].required)
+        data[option.code] = 'Test value'
+        valid_form = self._get_basket_form(
+            basket=self.basket, product=self.product, data=data,
+        )
+        self.assertTrue(valid_form.is_valid())
+
+    def _test_add_to_basket_with_specific_option_type(
+            self, option_type, invalid_value, valid_value
+    ):
+        option = OptionFactory(required=True, type=option_type)
+        self.product.product_class.options.add(option)
+        data = {'quantity': 1, option.code: invalid_value}
+        invalid_form = self._get_basket_form(
+            basket=self.basket, product=self.product, data=data,
+        )
+        self.assertFalse(invalid_form.is_valid())
+        data[option.code] = valid_value
+        valid_form = self._get_basket_form(
+            basket=self.basket, product=self.product, data=data,
+        )
+        self.assertTrue(valid_form.is_valid())
+
+    def test_add_to_basket_with_integer_option(self):
+        self._test_add_to_basket_with_specific_option_type(
+            Option.INTEGER, 1.55, 1,
+        )
+
+    def test_add_to_basket_with_float_option(self):
+        self._test_add_to_basket_with_specific_option_type(
+            Option.FLOAT, 'invalid_float', 1,
+        )
+
+    def test_add_to_basket_with_bool_option(self):
+        self._test_add_to_basket_with_specific_option_type(
+            Option.BOOLEAN, None, True,
+        )
+
+    def test_add_to_basket_with_date_option(self):
+        self._test_add_to_basket_with_specific_option_type(
+            Option.DATE, 'invalid_date', '2019-03-03',
+        )