Added ability to manage Catalogue.Option from the dashboard

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

     attribute_option_group_delete_view = get_class('dashboard.catalogue.views',
                                                    'AttributeOptionGroupDeleteView')
 
+    option_list_view = get_class('dashboard.catalogue.views', 'OptionListView')
+    option_create_view = get_class('dashboard.catalogue.views', 'OptionCreateView')
+    option_update_view = get_class('dashboard.catalogue.views', 'OptionUpdateView')
+    option_delete_view = get_class('dashboard.catalogue.views', 'OptionDeleteView')
+
     def get_urls(self):
         urls = [
             url(r'^products/(?P<pk>\d+)/$',
             url(r'^attribute-option-group/(?P<pk>\w+)/delete/$',
                 self.attribute_option_group_delete_view.as_view(),
                 name='catalogue-attribute-option-group-delete'),
+            url(r'^option/$',
+                self.option_list_view.as_view(),
+                name='catalogue-option-list'),
+            url(r'^option/create/$',
+                self.option_create_view.as_view(),
+                name='catalogue-option-create'),
+            url(r'^option/(?P<pk>\w+)/update/$',
+                self.option_update_view.as_view(),
+                name='catalogue-option-update'),
+            url(r'^option/(?P<pk>\w+)/delete/$',
+                self.option_delete_view.as_view(),
+                name='catalogue-option-delete'),
         ]
         return self.post_process_urls(urls)
 

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

 ProductRecommendation = get_model('catalogue', 'ProductRecommendation')
 AttributeOptionGroup = get_model('catalogue', 'AttributeOptionGroup')
 AttributeOption = get_model('catalogue', 'AttributeOption')
+Option = get_model('catalogue', 'Option')
 ProductSelect = get_class('dashboard.catalogue.widgets', 'ProductSelect')
 RelatedFieldWidgetWrapper = get_class('dashboard.widgets',
                                       'RelatedFieldWidgetWrapper')
     class Meta:
         model = AttributeOption
         fields = ['option']
+
+
+class OptionForm(forms.ModelForm):
+
+    class Meta:
+        model = Option
+        fields = ['name', 'type']

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

 Product = get_model('catalogue', 'Product')
 Category = get_model('catalogue', 'Category')
 AttributeOptionGroup = get_model('catalogue', 'AttributeOptionGroup')
+Option = get_model('catalogue', 'Option')
 
 
 class ProductTable(DashboardTable):
         fields = ('name',)
         sequence = ('name', 'option_summary', 'actions')
         per_page = settings.OSCAR_DASHBOARD_ITEMS_PER_PAGE
+
+
+class OptionTable(DashboardTable):
+    name = TemplateColumn(
+        verbose_name=_('Name'),
+        template_name='dashboard/catalogue/option_row_name.html',
+        order_by='name')
+    actions = TemplateColumn(
+        verbose_name=_('Actions'),
+        template_name='dashboard/catalogue/option_row_actions.html',
+        orderable=False)
+
+    icon = "reorder"
+    caption = ungettext_lazy("%s Option", "%s Options")
+
+    class Meta(DashboardTable.Meta):
+        model = Option
+        fields = ('name', 'type')
+        sequence = ('name', 'type', 'actions')
+        per_page = settings.OSCAR_DASHBOARD_ITEMS_PER_PAGE

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

 from oscar.core.loading import get_classes, get_model
 from oscar.views.generic import ObjectLookupView
 
+
 (ProductForm,
  ProductClassSelectForm,
  ProductSearchForm,
  ProductClassForm,
  CategoryForm,
  StockAlertSearchForm,
- AttributeOptionGroupForm) \
+ AttributeOptionGroupForm,
+ OptionForm) \
     = get_classes('dashboard.catalogue.forms',
                   ('ProductForm',
                    'ProductClassSelectForm',
                    'ProductClassForm',
                    'CategoryForm',
                    'StockAlertSearchForm',
-                   'AttributeOptionGroupForm'))
+                   'AttributeOptionGroupForm',
+                   'OptionForm'))
 (StockRecordFormSet,
  ProductCategoryFormSet,
  ProductImageFormSet,
                    'ProductRecommendationFormSet',
                    'ProductAttributesFormSet',
                    'AttributeOptionFormSet'))
-ProductTable, CategoryTable, AttributeOptionGroupTable \
+ProductTable, CategoryTable, AttributeOptionGroupTable, OptionTable \
     = get_classes('dashboard.catalogue.tables',
                   ('ProductTable', 'CategoryTable',
-                   'AttributeOptionGroupTable'))
+                   'AttributeOptionGroupTable', 'OptionTable'))
 (PopUpWindowCreateMixin,
  PopUpWindowUpdateMixin,
  PopUpWindowDeleteMixin) \
 StockAlert = get_model('partner', 'StockAlert')
 Partner = get_model('partner', 'Partner')
 AttributeOptionGroup = get_model('catalogue', 'AttributeOptionGroup')
+Option = get_model('catalogue', 'Option')
 
 
 def filter_products(queryset, user):
             messages.info(self.request, _("Attribute Option Group deleted successfully"))
         url = reverse("dashboard:catalogue-attribute-option-group-list")
         return self.get_url_with_querystring(url)
+
+
+class OptionListView(SingleTableView):
+
+    template_name = 'dashboard/catalogue/option_list.html'
+    model = Option
+    table_class = OptionTable
+    context_table_name = 'options'
+
+
+class OptionCreateUpdateView(generic.UpdateView):
+
+    template_name = 'dashboard/catalogue/option_form.html'
+    model = Option
+    form_class = OptionForm
+
+    def forms_invalid(self, *args, **kwargs):
+        messages.error(
+            self.request,
+            _("Your submitted data was not valid - please correct the errors below")
+        )
+        return super().form_invalid(*args, **kwargs)
+
+    def get_context_data(self, **kwargs):
+        ctx = super().get_context_data(**kwargs)
+        ctx["title"] = self.get_title()
+        return ctx
+
+
+class OptionCreateView(OptionCreateUpdateView):
+
+    def get_object(self):
+        return None
+
+    def get_title(self):
+        return _("Add a new Option")
+
+    def get_success_url(self):
+        messages.info(self.request, _("Option created successfully"))
+        url = reverse("dashboard:catalogue-option-list")
+        return url
+
+
+class OptionUpdateView(OptionCreateUpdateView):
+
+    def get_object(self):
+        attribute_option_group = get_object_or_404(Option, pk=self.kwargs['pk'])
+        return attribute_option_group
+
+    def get_title(self):
+        return _("Update Option '%s'") % self.object.name
+
+    def get_success_url(self):
+        messages.info(self.request, _("Option updated successfully"))
+        url = reverse("dashboard:catalogue-option-list")
+        return url
+
+
+class OptionDeleteView(generic.DeleteView):
+
+    template_name = 'dashboard/catalogue/option_delete.html'
+    model = Option
+
+    def get_context_data(self, **kwargs):
+        ctx = super().get_context_data(**kwargs)
+
+        ctx['title'] = _("Delete Option '%s'") % self.object.name
+
+        products = self.object.product_set.count()
+        product_classes = self.object.productclass_set.count()
+        if any([products, product_classes]):
+            ctx['disallow'] = True
+            ctx['title'] = _("Unable to delete '%s'") % self.object.name
+            if products:
+                messages.error(
+                    self.request,
+                    _("%i products are still assigned to this option") % products
+                )
+            if product_classes:
+                messages.error(
+                    self.request,
+                    _("%i product classes are still assigned to this option") % product_classes
+                )
+
+        return ctx
+
+    def get_success_url(self):
+        messages.info(self.request, _("Option deleted successfully"))
+        url = reverse("dashboard:catalogue-option-list")
+        return url

src/oscar/defaults.py

                 'label': _('Low stock alerts'),
                 'url_name': 'dashboard:stock-alert-list',
             },
+            {
+                'label': _('Options'),
+                'url_name': 'dashboard:catalogue-option-list',
+            },
         ]
     },
     {

src/oscar/templates/oscar/dashboard/catalogue/option_delete.html

+{% extends 'dashboard/layout.html' %}
+{% load i18n %}
+
+{% block title %}
+    {{ title }} | {% trans "Create Option" %} | {{ block.super }}
+{% endblock %}
+
+{% block body_class %}{{ block.super }} create-page{% endblock %}
+
+{% block breadcrumbs %}
+    <ul class="breadcrumb">
+        <li>
+            <a href="{% url 'dashboard:index' %}">{% trans "Dashboard" %}</a>
+        </li>
+        <li>
+            <a href="{% url 'dashboard:catalogue-option-list' %}">{% trans "Options" %}</a>
+        </li>
+        <li class="active">{% trans "Delete Option?" %}</li>
+    </ul>
+{% endblock %}
+
+{% block headertext %}
+    {{ title }}
+{% endblock %}
+
+{% block dashboard_content %}
+    {% if disallow %}
+        <p>{% trans "Please make sure option is not assigned to Products or Product Classes before deletion." %}</p>
+    {% else %}
+        <div class="table-header">
+            <h2>{% trans "Delete Option" %}</h2>
+        </div>
+        <form action="." method="post" class="well">
+            {% csrf_token %}
+            {% for key, value in http_get_params.items %}
+                <input type="hidden" name="{{ key }}" value="{{ value }}" />
+            {% endfor %}
+            <p>
+                {% blocktrans with name=object.name %}Delete Option <strong>{{ name }}</strong> - are you sure?{% endblocktrans %}
+            </p>
+            <div class="form-actions">
+                <a href="{% url 'dashboard:catalogue-option-list' %}">
+                    {% trans "Cancel" %}
+                </a>
+                <button type="submit" class="btn btn-danger" data-loading-text="{% trans 'Deleting...' %}">
+                    {% trans "Delete" %}
+                </button>
+            </div>
+        </form>
+    {% endif %}
+{% endblock %}

src/oscar/templates/oscar/dashboard/catalogue/option_form.html

+{% extends 'dashboard/layout.html' %}
+{% load i18n %}
+
+{% block title %}
+    {{ title }} | {{ block.super }}
+{% endblock %}
+
+{% block body_class %}{{ block.super }} create-page{% endblock %}
+
+
+{% block breadcrumbs %}
+    <ul class="breadcrumb">
+        <li>
+            <a href="{% url 'dashboard:index' %}">{% trans "Dashboard" %}</a>
+        </li>
+        <li>
+            <a href="{% url 'dashboard:catalogue-option-list' %}">{% trans "Options" %}</a>
+        </li>
+        <li class="active">{{ title }}</li>
+    </ul>
+{% endblock %}
+
+{% block headertext %}{{ title }}{% endblock %}
+
+{% block dashboard_content %}
+    <form class="form-stacked wysiwyg fixed-actions" method="post" data-behaviour="affix-nav-errors">
+        {% csrf_token %}
+
+        {% block option_details %}
+            <div id="option_details">
+                <div class="table-header">
+                    <h3>{% trans "Option details" %}</h3>
+                </div>
+                <div class="well option-details">
+
+                    {% comment %}
+                        If the Option form has field_errors, partials/form_fields.html
+                        will render an error message.
+                        This means that there'll be 2 error messages,
+                        one from the partial and one from the view. Perhaps there should be
+                        an option allowing hiding of the error message in the template.
+                        For now we copy paste what we need from the template.
+                    {% endcomment %}
+
+                    {% if form.non_field_errors %}
+                        {% for error in form.non_field_errors %}
+                            <div class="alert alert-error control-group error">
+                                <span class="error-block"><i class="icon-exclamation-sign"></i> {{ error }}</span>
+                            </div>
+                        {% endfor %}
+                    {% endif %}
+
+                    {% for field in form %}
+                        {% include 'dashboard/partials/form_field.html' with field=field %}
+                    {% endfor %}
+                </div>
+            </div>
+        {% endblock %}
+
+        {% block fixed_actions_group %}
+            <div class="fixed-actions-group">
+                <div class="form-actions">
+                    <div class="pull-right">
+                        <a href="#" onclick="window.history.go(-1);return false">
+                            {% trans "Cancel" %}
+                        </a>
+                        {% trans "or" %}
+                        <button class="btn btn-large btn-primary" type="submit">
+                            {% trans "Save" %}
+                        </button>
+                    </div>
+                </div>
+            </div>
+        {% endblock fixed_actions_group %}
+    </form>
+
+{% endblock dashboard_content %}

src/oscar/templates/oscar/dashboard/catalogue/option_list.html

+{% extends 'dashboard/layout.html' %}
+{% load i18n %}
+{% load render_table from django_tables2 %}
+
+{% block title %}
+    {% trans "Options" %} | {{ block.super }}
+{% endblock %}
+
+{% block breadcrumbs %}
+    <ul class="breadcrumb">
+        <li>
+            <a href="{% url 'dashboard:index' %}">{% trans "Dashboard" %}</a>
+        </li>
+        <li class="active">{% trans "Options" %}</li>
+    </ul>
+{% endblock %}
+
+{% block header %}
+    <div class="page-header">
+        <a href="{% url 'dashboard:catalogue-option-create' %}" class="btn btn-primary btn-lg pull-right"><i class="icon-plus"></i> {% trans "Create new Option" %}</a>
+        <h1>{% trans "Option" %}</h1>
+    </div>
+{% endblock header %}
+
+{% block dashboard_content %}
+    {% if options %}
+        {% block product_list %}
+            <form action="." method="post">
+                {% csrf_token %}
+                {% render_table options %}
+            </form>
+        {% endblock product_list %}
+    {% else %}
+        <p>{% trans "No Option found." %}</p>
+    {% endif %}
+{% endblock dashboard_content %}

src/oscar/templates/oscar/dashboard/catalogue/option_row_actions.html

+{% load django_tables2 %}
+{% load i18n %}
+<div class="btn-toolbar">
+    <div class="btn-group">
+        <button class="btn btn-default dropdown-toggle" type="button" data-toggle="dropdown" aria-expanded="true">
+            {% trans "Actions" %}
+            <span class="caret"></span>
+        </button>
+        <ul class="dropdown-menu pull-right">
+            <li>
+                <a href="{% url 'dashboard:catalogue-option-update' pk=record.id %}{% querystring %}">{% trans "Edit Option" %}</a>
+            </li>
+            <li>
+                <a href="{% url 'dashboard:catalogue-option-delete' pk=record.id %}{% querystring %}">{% trans "Delete" %}</a>
+            </li>
+        </ul>
+    </div>
+</div>

src/oscar/templates/oscar/dashboard/catalogue/option_row_name.html

+{% load django_tables2 %}
+<a href="{% url 'dashboard:catalogue-option-update' pk=record.pk %}{% querystring %}">{{ value }}</a>

tests/functional/dashboard/test_catalogue_options.py

+from http import client as http_client
+
+from django.conf import settings
+from django.contrib.messages import ERROR, INFO
+from django.urls import reverse
+from django.utils.text import slugify
+from django.utils.translation import gettext
+
+from oscar.core.loading import get_class, get_model
+from oscar.test.factories import (
+    OptionFactory, ProductClassFactory, create_product)
+from oscar.test.testcases import WebTestCase
+
+
+Option = get_model('catalogue', 'Option')
+OptionForm = get_class('dashboard.catalogue.forms', 'OptionForm')
+
+
+class OptionCreateMixin(object):
+
+    def _set_up_display_create_form_vars(self):
+        self.url_name = 'dashboard:catalogue-option-create'
+        self.title = gettext("Add a new Option")
+
+    def _test_display_create_form_response(self):
+        response = self.response
+
+        self.assertEqual(response.status_code, http_client.OK)
+        self.assertTemplateUsed(response, 'dashboard/catalogue/option_form.html')
+        self.assertInContext(response, 'form')
+        self.assertIsInstance(response.context['form'], OptionForm)
+        self.assertTrue(response.context['form'].instance._state.adding)
+        self.assertInContext(response, 'title')
+        self.assertEqual(response.context['title'], self.title)
+
+    def _set_up_create_vars(self):
+        self.url_name = 'dashboard:catalogue-option-create'
+        self.option_name = 'Test Option'
+
+    def _set_up_create_success_vars(self):
+        self.success_url_name = 'dashboard:catalogue-option-list'
+        self.success_message = gettext("Option created successfully")
+
+    def _test_creation_of_objects(self):
+        # Test the creation of the option
+        self.assertEqual(1, Option.objects.all().count())
+        option = Option.objects.first()
+        self.assertEqual(option.name, self.option_name)
+
+
+class OptionUpdateMixin(object):
+
+    def _set_up_display_update_form_vars(self):
+        url_name = 'dashboard:catalogue-option-update'
+        self.url = reverse(url_name, kwargs={'pk': self.option.pk})
+        self.title = gettext("Update Option '%s'") % self.option.name
+
+    def _test_display_update_form_response(self):
+        response = self.response
+
+        self.assertEqual(response.status_code, http_client.OK)
+        self.assertTemplateUsed(response, 'dashboard/catalogue/option_form.html')
+        self.assertInContext(response, 'form')
+        self.assertIsInstance(response.context['form'], OptionForm)
+        self.assertEqual(response.context['form'].instance, self.option)
+        self.assertInContext(response, 'title')
+        self.assertEqual(response.context['title'], self.title)
+
+    def _set_up_update_vars(self):
+        url_name = 'dashboard:catalogue-option-update'
+        self.url = reverse(url_name, kwargs={'pk': self.option.pk})
+        self.option_name = 'Test Option'
+
+    def _set_up_update_success_vars(self):
+        self.success_url_name = 'dashboard:catalogue-option-list'
+        self.success_message = gettext("Option updated successfully")
+
+    def _test_update_of_objects(self):
+        # Test the update of the option
+        option = Option.objects.first()
+        self.assertEqual(option.name, self.option_name)
+
+
+class OptionDeleteMixin(object):
+
+    def _set_up_display_delete_form_vars(self):
+        url_name = 'dashboard:catalogue-option-delete'
+        self.url = reverse(url_name, kwargs={'pk': self.option.pk})
+
+    def _set_up_display_delete_form_allowed_vars(self):
+        self.title = gettext("Delete Option '%s'") % self.option.name
+
+    def _set_up_display_delete_form_disallowed_objects(self):
+        product_class = ProductClassFactory()
+        product = create_product(product_class=product_class)
+        product_class.options.add(self.option)
+        product.product_options.add(self.option)
+
+    def _set_up_display_delete_form_disallowed_vars(self):
+        self.title = gettext("Unable to delete '%s'") % self.option.name
+        self.error_product_message = gettext("1 products are still assigned to this option")
+        self.error_class_message = gettext("1 product classes are still assigned to this option")
+
+    def _test_display_delete_form_response(self):
+        response = self.response
+
+        self.assertEqual(response.status_code, http_client.OK)
+        self.assertTemplateUsed(response, 'dashboard/catalogue/option_delete.html')
+        self.assertInContext(response, 'title')
+        self.assertEqual(response.context['title'], self.title)
+
+    def _test_display_delete_disallowed_response(self):
+        response = self.response
+
+        self.assertInContext(response, 'disallow')
+        self.assertTrue(response.context['disallow'])
+        messages = list(response.context['messages'])
+        self.assertEqual(len(messages), 2)
+        self.assertEqual(messages[0].level, ERROR)
+        self.assertEqual(messages[1].level, ERROR)
+        self.assertEqual(messages[0].message, self.error_product_message)
+        self.assertEqual(messages[1].message, self.error_class_message)
+
+    def _set_up_delete_vars(self):
+        url_name = 'dashboard:catalogue-option-delete'
+        self.url = reverse(url_name, kwargs={'pk': self.option.pk})
+
+    def _set_up_delete_success_vars(self):
+        self.success_url_name = 'dashboard:catalogue-option-list'
+        self.success_message = gettext("Option deleted successfully")
+
+    def _test_deletion_of_objects(self):
+        # Test the deletion of the option
+        option_exists = Option.objects.exists()
+        self.assertFalse(option_exists)
+
+
+class TestResponseOptionMixin(object):
+
+    def _test_success_response(self):
+        response = self.response
+
+        self.assertEqual(response.status_code, http_client.FOUND)
+        self.assertRedirectsTo(response, self.success_url_name)
+        messages = list(response.follow().context['messages'])
+        self.assertEqual(len(messages), 1)
+        self.assertEqual(messages[0].level, INFO)
+        self.assertEqual(messages[0].message, self.success_message)
+
+
+class TestOptionCreateView(OptionCreateMixin,
+                           TestResponseOptionMixin,
+                           WebTestCase):
+    is_staff = True
+
+    def test_display_create_form(self):
+        self._set_up_display_create_form_vars()
+
+        self.response = self.get(reverse(self.url_name))
+
+        # Test the response
+        self._test_display_create_form_response()
+
+    def test_create_option(self):
+        self._set_up_create_vars()
+        self._set_up_create_success_vars()
+
+        form = self.get(reverse(self.url_name)).form
+        form['name'] = self.option_name
+        self.response = form.submit()
+
+        # Test the creation of the option
+        self._test_creation_of_objects()
+
+        # Test the response
+        self._test_success_response()
+
+
+class TestOptionUpdateView(OptionUpdateMixin,
+                           TestResponseOptionMixin,
+                           WebTestCase):
+    is_staff = True
+
+    def setUp(self):
+        super().setUp()
+
+        self.option = OptionFactory()
+
+    def test_display_update_form(self):
+        self._set_up_display_update_form_vars()
+
+        self.response = self.get(self.url)
+
+        # Test the response
+        self._test_display_update_form_response()
+
+    def test_update_option(self):
+        self._set_up_update_vars()
+        self._set_up_update_success_vars()
+
+        form = self.get(self.url).form
+        form['name'] = self.option_name
+        self.response = form.submit()
+
+        # Test the update of the attribute option
+        self._test_update_of_objects()
+
+        # Test the response
+        self._test_success_response()
+
+
+class TestOptionListView(WebTestCase):
+    is_staff = True
+
+    def test_display_pagination_navigation(self):
+        url_name = 'dashboard:catalogue-option-list'
+        per_page = settings.OSCAR_DASHBOARD_ITEMS_PER_PAGE
+        option_name = 'Test Option #%d'
+
+        for i in range(0, int(1.5 * per_page)):
+            name = option_name % i
+            OptionFactory(name=name, code=slugify(name))
+
+        page = self.get(reverse(url_name))
+
+        # Test the pagination
+        self.assertContains(page, 'Page 1 of 2')
+
+
+class TestOptionDeleteView(OptionDeleteMixin,
+                           TestResponseOptionMixin,
+                           WebTestCase):
+    is_staff = True
+
+    def setUp(self):
+        super().setUp()
+
+        self.option = OptionFactory()
+
+    def test_display_delete_form(self):
+        self._set_up_display_delete_form_vars()
+        self._set_up_display_delete_form_allowed_vars()
+
+        self.response = self.get(self.url)
+
+        # Test the response
+        self._test_display_delete_form_response()
+
+    def test_display_disallowed_delete_via_regular_window(self):
+        self._set_up_display_delete_form_vars()
+        self._set_up_display_delete_form_disallowed_vars()
+        self._set_up_display_delete_form_disallowed_objects()
+
+        self.response = self.get(self.url)
+
+        # Test the response
+        self._test_display_delete_form_response()
+        self._test_display_delete_disallowed_response()
+
+    def test_delete_option(self):
+        self._set_up_delete_vars()
+        self._set_up_delete_success_vars()
+
+        form = self.get(self.url).form
+        self.response = form.submit()
+
+        # Test the deletion of the option
+        self._test_deletion_of_objects()
+
+        # Test the response
+        self._test_success_response()