Manage excluded_products in ranges dashboard (#4073)

File Upload for excluded_products

* Add more tests and fix file upload processor by comma.

---------

Co-authored-by: Joey Jurjens <joey@highbiza.nl>

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

 
 Product = get_model('catalogue', 'Product')
 Range = get_model('offer', 'Range')
+RangeProductFileUpload = get_model("offer", "RangeProductFileUpload")
 
 UPC_SET_REGEX = re.compile(r'[^,\s]+')
 
     file_upload = forms.FileField(
         label=_("File of SKUs or UPCs"), required=False, max_length=255,
         help_text=_('Either comma-separated, or one identifier per line'))
+    upload_type = forms.CharField(widget=forms.HiddenInput(), required=False)
 
     def __init__(self, range, *args, **kwargs):
         self.range = range
         super().__init__(*args, **kwargs)
 
+    def clean_query_with_upload_type(self, raw, upload_type):
+        # Check that the search matches some products
+        ids = set(UPC_SET_REGEX.findall(raw))
+        # switch for included or excluded products
+        if upload_type == RangeProductFileUpload.EXCLUDED_PRODUCTS_TYPE:
+            products = self.range.excluded_products.all()
+            action = _('excluded from this range')
+        else:
+            products = self.range.all_products()
+            action = _('added to this range')
+        existing_skus = set(products.values_list(
+            'stockrecords__partner_sku', flat=True))
+        existing_upcs = set(products.values_list('upc', flat=True))
+        existing_ids = existing_skus.union(existing_upcs)
+        new_ids = ids - existing_ids
+        if len(new_ids) == 0:
+            self.add_error(
+                'query',
+                _("The products with SKUs or UPCs matching %(skus)s have "
+                  "already been %(action)s") % {'skus': ", ".join(ids),
+                                                'action': action}
+            )
+        else:
+            self.products = Product._default_manager.filter(
+                Q(stockrecords__partner_sku__in=new_ids)
+                | Q(upc__in=new_ids))
+            if len(self.products) == 0:
+                self.add_error(
+                    'query',
+                    _("No products exist with a SKU or UPC matching %s")
+                    % ", ".join(ids))
+            found_skus = set(self.products.values_list(
+                'stockrecords__partner_sku', flat=True))
+            found_upcs = set(self.products.values_list('upc', flat=True))
+            found_ids = found_skus.union(found_upcs)
+            self.missing_skus = new_ids - found_ids
+            self.duplicate_skus = existing_ids.intersection(ids)
+
     def clean(self):
         clean_data = super().clean()
         if not clean_data.get('query') and not clean_data.get('file_upload'):
             raise forms.ValidationError(
                 _("You must submit either a list of SKU/UPCs or a file"))
+        raw = clean_data['query']
+        if raw:
+            self.clean_query_with_upload_type(raw, clean_data['upload_type'])
         return clean_data
 
+    def get_products(self):
+        return self.products if hasattr(self, 'products') else []
+
+    def get_missing_skus(self):
+        return self.missing_skus
+
+    def get_duplicate_skus(self):
+        return self.duplicate_skus
+
+
+class RangeExcludedProductForm(RangeProductForm):
+    """
+    Form to add products in range.excluded_products
+    """
+
     def clean_query(self):
         raw = self.cleaned_data['query']
         if not raw:
 
         # Check that the search matches some products
         ids = set(UPC_SET_REGEX.findall(raw))
-        products = self.range.all_products()
+        products = self.range.excluded_products.all()
         existing_skus = set(products.values_list(
             'stockrecords__partner_sku', flat=True))
         existing_upcs = set(products.values_list('upc', flat=True))
         self.duplicate_skus = existing_ids.intersection(ids)
 
         return raw
-
-    def get_products(self):
-        return self.products if hasattr(self, 'products') else []
-
-    def get_missing_skus(self):
-        return self.missing_skus
-
-    def get_duplicate_skus(self):
-        return self.duplicate_skus

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

 from django.contrib import messages
 from django.core import exceptions
 from django.db.models import Count
-from django.http import HttpResponseRedirect
-from django.shortcuts import HttpResponse, get_object_or_404
+from django.shortcuts import HttpResponse, get_object_or_404, redirect
 from django.template.loader import render_to_string
 from django.urls import reverse
 from django.utils.translation import gettext_lazy as _
 RangeProduct = get_model('offer', 'RangeProduct')
 RangeProductFileUpload = get_model('offer', 'RangeProductFileUpload')
 Product = get_model('catalogue', 'Product')
-RangeForm, RangeProductForm = get_classes('dashboard.ranges.forms',
-                                          ['RangeForm', 'RangeProductForm'])
+RangeForm, RangeProductForm = get_classes(
+    'dashboard.ranges.forms', ['RangeForm', 'RangeProductForm'])
 
 
 class RangeListView(ListView):
     model = Product
     template_name = 'oscar/dashboard/ranges/range_product_list.html'
     context_object_name = 'products'
-    actions = ('remove_selected_products', 'add_products')
+    actions = ('add_products', 'add_excluded_products',
+               'remove_selected_products', 'remove_excluded_products')
     form_class = RangeProductForm
     paginate_by = settings.OSCAR_DASHBOARD_ITEMS_PER_PAGE
 
+    def get(self, request, **kwargs):
+        self.upload_type = request.GET.get('upload_type', "")
+        return super().get(request, **kwargs)
+
     def post(self, request, *args, **kwargs):
         self.object_list = self.get_queryset()
+        self.upload_type = request.POST.get('upload_type', "")
         if request.POST.get('action', None) == 'add_products':
             return self.add_products(request)
+        if request.POST.get('action', None) == 'add_excluded_products':
+            return self.add_excluded_products(request)
+        if request.POST.get('action', None) == 'remove_excluded_products':
+            return self.remove_excluded_products(request)
         return super().post(request, *args, **kwargs)
 
     def get_range(self):
         range = self.get_range()
         ctx['range'] = range
         if 'form' not in ctx:
-            ctx['form'] = self.form_class(range)
+            ctx['form'] = self.form_class(range, initial={
+                "upload_type": RangeProductFileUpload.INCLUDED_PRODUCTS_TYPE})
+        if 'form_excluded' not in ctx:
+            ctx["form_excluded"] = self.form_class(range, initial={
+                "upload_type": RangeProductFileUpload.EXCLUDED_PRODUCTS_TYPE})
+        ctx['file_uploads_included'] = range.file_uploads.filter(
+            upload_type=RangeProductFileUpload.INCLUDED_PRODUCTS_TYPE)
+        ctx['file_uploads_excluded'] = range.file_uploads.filter(
+            upload_type=RangeProductFileUpload.EXCLUDED_PRODUCTS_TYPE)
+        ctx["upload_type"] = self.upload_type
         return ctx
 
     def remove_selected_products(self, request, products):
         num_products = len(products)
         messages.success(
             request,
-            ngettext("Removed %d product from range", "Removed %d products from range", num_products) % num_products
+            ngettext("Removed %d product from range",
+                     "Removed %d products from range",
+                     num_products) % num_products
+        )
+        return redirect(
+            reverse('dashboard:range-products', kwargs={'pk': range.pk})
         )
-        return HttpResponseRedirect(self.get_success_url(request))
 
     def add_products(self, request):
         range = self.get_range()
 
         self.handle_query_products(request, range, form)
         self.handle_file_products(request, range, form)
-        return HttpResponseRedirect(self.get_success_url(request))
+        return redirect(
+            reverse('dashboard:range-products', kwargs={'pk': range.pk})
+        )
+
+    def add_excluded_products(self, request):
+        range = self.get_range()
+        form = self.form_class(
+            range, request.POST, request.FILES, initial={
+                "upload_type": RangeProductFileUpload.EXCLUDED_PRODUCTS_TYPE}
+        )
+        if not form.is_valid():
+            ctx = self.get_context_data(form_excluded=form,
+                                        object_list=self.object_list)
+            return self.render_to_response(ctx)
+
+        self.handle_query_products(request, range, form)
+        self.handle_file_products(request, range, form)
+        return redirect(
+            reverse('dashboard:range-products', kwargs={'pk': range.pk})
+            + '?upload_type=excluded'
+        )
+
+    def remove_excluded_products(self, request):
+        product_ids = request.POST.getlist('selected_product', None)
+        products = self.model.objects.filter(id__in=product_ids)
+        range = self.get_range()
+        for product in products:
+            range.excluded_products.remove(product)
+        num_products = len(products)
+        messages.success(
+            request,
+            ngettext(
+                "Removed %d product from excluded list",
+                "Removed %d products from excluded list",
+                num_products) % num_products
+        )
+        return redirect(
+            reverse('dashboard:range-products', kwargs={'pk': range.pk})
+            + '?upload_type=excluded'
+        )
 
     def handle_query_products(self, request, range, form):
         products = form.get_products()
         if not products:
             return
-
         for product in products:
-            range.add_product(product)
-
+            if form.cleaned_data["upload_type"] == \
+                    RangeProductFileUpload.EXCLUDED_PRODUCTS_TYPE:
+                range.excluded_products.add(product)
+                action = _('excluded from this range')
+            else:
+                range.add_product(product)
+                action = _('added to this range')
         num_products = len(products)
         messages.success(
             request,
-            ngettext("%d product added to range", "%d products added to range", num_products) % num_products
+            ngettext("%(num_products)d product has been %(action)s",
+                     "%(num_products)d products have been %(action)s",
+                     num_products) % {'num_products': num_products,
+                                      'action': action}
         )
         dupe_skus = form.get_duplicate_skus()
         if dupe_skus:
             messages.warning(
                 request,
-                _("The products with SKUs or UPCs matching %s are already "
-                  "in this range") % ", ".join(dupe_skus))
+                _("The products with SKUs or UPCs matching %(skus)s have "
+                  "already been %(action)s") % {'skus': ", ".join(dupe_skus),
+                                                'action': action})
 
         missing_skus = form.get_missing_skus()
         if missing_skus:
         if 'file_upload' not in request.FILES:
             return
         f = request.FILES['file_upload']
-        upload = self.create_upload_object(request, range, f)
+        upload = self.create_upload_object(
+            request, range, f, form.cleaned_data["upload_type"])
         products = upload.process(TextIOWrapper(f, encoding=request.encoding))
         if not upload.was_processing_successful():
             messages.error(request, upload.error_message)
         else:
+            if form.cleaned_data["upload_type"] == \
+                    RangeProductFileUpload.EXCLUDED_PRODUCTS_TYPE:
+                action = "excluded from this range"
+            else:
+                action = "added to this range"
             msg = render_to_string(
                 'oscar/dashboard/ranges/messages/range_products_saved.html',
                 {'range': range,
-                 'upload': upload})
+                 'upload': upload,
+                 'action': action})
             messages.success(request, msg, extra_tags='safe noicon block')
         self.check_imported_products_sku_duplicates(request, products)
 
-    def create_upload_object(self, request, range, f):
+    def create_upload_object(self, request, range, f, upload_type):
         upload = RangeProductFileUpload.objects.create(
             range=range,
             uploaded_by=request.user,
             filepath=f.name,
-            size=f.size
+            size=f.size,
+            upload_type=upload_type
         )
         return upload
 

src/oscar/apps/offer/abstract_models.py

         AUTH_USER_MODEL,
         on_delete=models.CASCADE,
         verbose_name=_("Uploaded By"))
-    date_uploaded = models.DateTimeField(_("Date Uploaded"), auto_now_add=True, db_index=True)
+    date_uploaded = models.DateTimeField(_(
+        "Date Uploaded"), auto_now_add=True, db_index=True)
+
+    INCLUDED_PRODUCTS_TYPE = "included"
+    EXCLUDED_PRODUCTS_TYPE = "excluded"
+    UPLOAD_TYPE_CHOICES = [
+        (INCLUDED_PRODUCTS_TYPE, "Included products upload"),
+        (EXCLUDED_PRODUCTS_TYPE, "Excluded products upload"),
+    ]
+    upload_type = models.CharField(
+        max_length=8, choices=UPLOAD_TYPE_CHOICES,
+        default=INCLUDED_PRODUCTS_TYPE)
 
     PENDING, FAILED, PROCESSED = 'Pending', 'Failed', 'Processed'
     choices = (
     def process(self, file_obj):
         """
         Process the file upload and add products to the range
+        or add products to range.excluded_products
         """
         all_ids = set(self.extract_ids(file_obj))
-        products = self.range.all_products()
+        if self.upload_type == self.INCLUDED_PRODUCTS_TYPE:
+            products = self.range.all_products()
+        elif self.upload_type == self.EXCLUDED_PRODUCTS_TYPE:
+            products = self.range.excluded_products.all()
+        else:
+            raise ValueError(
+                "Unable to process upload type: %s" % self.upload_type)
         existing_skus = products.values_list(
             'stockrecords__partner_sku', flat=True)
         existing_skus = set(filter(bool, existing_skus))
             models.Q(stockrecords__partner_sku__in=new_ids)
             | models.Q(upc__in=new_ids))
         for product in products:
-            self.range.add_product(product)
+            if self.upload_type == self.INCLUDED_PRODUCTS_TYPE:
+                self.range.add_product(product)
+            else:
+                self.range.excluded_products.add(product)
 
         # Processing stats
         found_skus = products.values_list(
         reader = csv.reader(file_obj)
         for line in reader:
             if line:
-                yield line[0]
+                yield from line

src/oscar/apps/offer/migrations/0011_rangeproductfileupload_included.py

+# Generated by Django 3.2.18 on 2023-03-14 11:11
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('offer', '0010_conditionaloffer_combinations'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='rangeproductfileupload',
+            name='upload_type',
+            field=models.CharField(choices=[('included', 'Included products upload'), ('excluded', 'Excluded products upload')], default='included', max_length=8),
+        ),
+    ]

src/oscar/apps/offer/models.py

 
     __all__.append('RangeProductFileUpload')
 
-
 # Import the benefits and the conditions. Required after initializing the
 # parent models to allow overriding them
 

src/oscar/templates/oscar/dashboard/ranges/messages/range_products_saved.html

 <ul>
     {% if upload.num_new_skus %}
         <li>
-            {% blocktrans count n=upload.num_new_skus %}
-                <strong>{{ n }}</strong> product added
+            {% blocktrans with action=action count n=upload.num_new_skus %}
+                <strong>{{ n }}</strong> product has been {{ action }}
             {% plural %}
-                <strong>{{ n }}</strong> products added
+                <strong>{{ n }}</strong> products have been {{ action }}
             {% endblocktrans %}
         </li>
     {% endif %}

src/oscar/templates/oscar/dashboard/ranges/range_product_list.html

 
 {% block dashboard_content %}
 
-    {% if range.includes_all_products %}
+<div class="tabbable dashboard">
+
+  <ul class="nav nav-tabs mb-0" role="tablist">
+    {% block nav_tabs %}
+      <li class="nav-item">
+        <a class="nav-link {% if not upload_type == "excluded" %}active{% endif %}" href="#included" data-toggle="tab">
+          {% trans "Products in range" %}
+        </a>
+      </li>
+      <li class="nav-item">
+        <a class="nav-link {% if upload_type == "excluded" %}active{% endif %}" href="#excluded" data-toggle="tab">
+          {% trans "Products excluded from range" %}
+        </a>
+      </li>
+      {% endblock nav_tabs %}
+  </ul>
+
+  <div class="tab-content">
+
+    <div class="tab-pane fade {% if not upload_type == "excluded" %}show active{% endif %}" id="included" role="tabpanel">
+
+      {% if range.includes_all_products %}
         {% trans "This range contains all products. To add products manually, please unselect the 'Includes All Products' option on the edit range page." %}
-    {% else %}
+      {% else %}
 
-    <div class="table-header">
-        <h3>{% trans "Add products" %}</h3>
-    </div>
+        <div class="table-header">
+          <h3>{% trans "Add products" %}</h3>
+        </div>
 
         <div class="card card-body bg-light">
 
-            <form method="post" class="form-stacked" enctype="multipart/form-data">
-                {% csrf_token %}
-                <input type="hidden" name="action" value="add_products"/>
-                {% include 'oscar/dashboard/partials/form_fields.html' with form=form %}
-                <div class="controls">
-                    <button type="submit" class="btn btn-primary" data-loading-text="{% trans 'Running...' %}">{% trans "Go!" %}</button>
-                </div>
-            </form>
+          <form method="post" class="form-stacked" enctype="multipart/form-data">
+            {% csrf_token %}
+            <input type="hidden" name="action" value="add_products"/>
+            {% include 'oscar/dashboard/partials/form_fields.html' with form=form %}
+            <div class="controls">
+              <button type="submit" class="btn btn-primary" data-loading-text="{% trans 'Running...' %}">
+                {% trans "Go!" %}
+              </button>
+            </div>
+          </form>
 
-            {% with uploads=range.file_uploads.all %}
-                {% if uploads %}
-                    <div class="table-header">
-                        <h3>{% trans "Upload history" %}</h3>
-                    </div>
-                    <table class="table table-striped table-bordered table-hover">
-                        <thead>
-                            <tr>
-                                <th>{% trans "Filename" %}</th>
-                                <th>{% trans "New products" %}</th>
-                                <th>{% trans "Duplicate products" %}</th>
-                                <th>{% trans "Unknown products" %}</th>
-                                <th>{% trans "Date uploaded" %}</th>
-                            </tr>
-                        </thead>
-                        <tbody>
-                            {% for upload in uploads %}
-                                <tr>
-                                    <td>{{ upload.filepath }}</td>
-                                    <td>{{ upload.num_new_skus }}</td>
-                                    <td>{{ upload.num_duplicate_skus }}</td>
-                                    <td>{{ upload.num_unknown_skus }}</td>
-                                    <td>{{ upload.date_uploaded }}</td>
-                                </tr>
-                            {% endfor %}
-                        </tbody>
-                    </table>
-                {% endif %}
-            {% endwith %}
-
-            {% if products %}
-                <form method="post">
-                    {% csrf_token %}
-                    <table class="table table-striped table-bordered table-hover">
-                        <caption>
-                            <h3 class="float-left">{% trans "Products in range" %}</h3>
-                            <div class="float-right">
-                                <input type="hidden" name="action" value="remove_selected_products" />
-                                <button type="submit" class="btn btn-secondary" data-loading-text="{% trans 'Removing...' %}">{% trans "Remove selected products" %}</button>
-                            </div>
-                        </caption>
-                        <thead>
-                            <tr>
-                                <th></th>
-                                <th>{% trans "UPC" %}</th>
-                                <th>{% trans "Title" context "Product title" %}</th>
-                                <th>{% trans "Is product discountable?" %}</th>
-                                <th></th>
-                            </tr>
-                        </thead>
-                        <tbody class="product_list">
-                        {% for product in products %}
-                            <tr id="product_{{ product.pk }}">
-                                <td>
-                                    <input type="checkbox" name="selected_product" value="{{ product.id }}" />
-                                </td>
-                                <td>{{ product.upc|default:"-" }}</td>
-                                <td><a href="{% url 'dashboard:catalogue-product' pk=product.id %}">{{ product.get_title }}</a></td>
-                                <td>{% if product.get_is_discountable %}{% trans "Yes" %}{% else %}{% trans "No" %}{% endif %}</td>
-                                <td>
-                                    <a class="btn btn-danger" href="#" data-behaviours="remove">{% trans "Remove" %}</a>
-                                    {% if range.is_reorderable %}
-                                        <a href="#" class="btn btn-info btn-handle"><i class="fas fa-arrows-alt"></i> {% trans "Re-order" context "Change the sequence order" %}</a>
-                                    {% endif %}
-                                </td>
-                            </tr>
-                        {% endfor %}
-                        </tbody>
-                    </table>
-                    {% include "oscar/dashboard/partials/pagination.html" %}
-                </form>
-
-            {% else %}
-                <table class="table table-striped table-bordered table-hover">
-                    <caption>
-                        {% trans "Products in Range" %}
-                    </caption>
-                    <tr><td>{% trans "No products found." %}</td></tr>
-                </table>
+          {% with uploads=file_uploads_included %}
+            {% if uploads %}
+            <div class="table-header">
+              <h3>{% trans "Upload history" %}</h3>
+            </div>
+            <table class="table table-striped table-bordered table-hover">
+              <thead>
+                <tr>
+                  <th>{% trans "Filename" %}</th>
+                  <th>{% trans "New products" %}</th>
+                  <th>{% trans "Duplicate products" %}</th>
+                  <th>{% trans "Unknown products" %}</th>
+                  <th>{% trans "Date uploaded" %}</th>
+                </tr>
+              </thead>
+              <tbody>
+                {% for upload in uploads %}
+                  <tr>
+                    <td>{{ upload.filepath }}</td>
+                    <td>{{ upload.num_new_skus }}</td>
+                    <td>{{ upload.num_duplicate_skus }}</td>
+                    <td>{{ upload.num_unknown_skus }}</td>
+                    <td>{{ upload.date_uploaded }}</td>
+                  </tr>
+                {% endfor %}
+              </tbody>
+            </table>
             {% endif %}
+          {% endwith %}
 
+          {% if products %}
+          <form method="post">
+            {% csrf_token %}
+            <table class="table table-striped table-bordered table-hover">
+             <caption>
+                <h3 class="float-left">{% trans "Products in range" %}</h3>
+                <div class="float-right">
+                  <input type="hidden" name="action" value="remove_selected_products" />
+                  <button type="submit" class="btn btn-secondary" data-loading-text="{% trans 'Removing...' %}">
+                    {% trans "Remove selected products" %}
+                  </button>
+                </div>
+              </caption>
+              <thead>
+                <tr>
+                  <th></th>
+                  <th>{% trans "UPC" %}</th>
+                  <th>{% trans "Title" context "Product title" %}</th>
+                  <th>{% trans "Is product discountable?" %}</th>
+                  <th></th>
+                </tr>
+              </thead>
+              <tbody class="product_list">
+                {% for product in products %}
+                  <tr id="product_{{ product.pk }}">
+                    <td>
+                      <input type="checkbox" name="selected_product" value="{{ product.id }}" />
+                    </td>
+                    <td>{{ product.upc|default:"-" }}</td>
+                    <td><a href="{% url 'dashboard:catalogue-product' pk=product.id %}">{{ product.get_title }}</a></td>
+                    <td>{% if product.get_is_discountable %}{% trans "Yes" %}{% else %}{% trans "No" %}{% endif %}</td>
+                    <td>
+                      <a class="btn btn-danger" href="#" data-behaviours="remove">{% trans "Remove" %}</a>
+                      {% if range.is_reorderable %}
+                        <a href="#" class="btn btn-info btn-handle"><i class="fas fa-arrows-alt"></i>
+                           {% trans "Re-order" context "Change the sequence order" %}
+                        </a>
+                      {% endif %}
+                    </td>
+                  </tr>
+                {% endfor %}
+              </tbody>
+            </table>
+            {% include "oscar/dashboard/partials/pagination.html" %}
+          </form>
+
+          {% else %}
+          <table class="table table-striped table-bordered table-hover">
+            <caption>
+              {% trans "Products in Range" %}
+            </caption>
+            <tr><td>{% trans "No products found." %}</td></tr>
+          </table>
+          {% endif %}
+
+        </div>
+
+      {% endif %}
 
     </div>
-        {% endif %}
-        <div class="form-actions">
-            <a href="{% url 'dashboard:range-update' pk=range.id %}" class="btn btn-primary">{% trans "Edit range" %}</a> {% trans "or" %}
-            <a href="{% url 'dashboard:range-list' %}" class="">{% trans "return to range list" %}</a>
+
+    <div class="tab-pane fade {% if upload_type == "excluded" %}show active{% endif %}" id="excluded" role="tabpanel">
+
+        <div class="table-header">
+          <h3>{% trans "Exclude products" %}</h3>
         </div>
 
+        <div class="card card-body bg-light">
+
+          <form method="post" class="form-stacked" enctype="multipart/form-data">
+            {% csrf_token %}
+            <input type="hidden" name="action" value="add_excluded_products"/>
+            {% include 'oscar/dashboard/partials/form_fields.html' with form=form_excluded %}
+            <div class="controls">
+              <button type="submit" class="btn btn-primary" data-loading-text="{% trans 'Running...' %}">
+                {% trans "Go!" %}
+              </button>
+            </div>
+          </form>
+
+          {% with uploads=file_uploads_excluded %}
+          {% if uploads %}
+            <div class="table-header">
+              <h3>{% trans "Upload history" %}</h3>
+            </div>
+            <table class="table table-striped table-bordered table-hover">
+              <thead>
+                <tr>
+                  <th>{% trans "Filename" %}</th>
+                  <th>{% trans "New products" %}</th>
+                  <th>{% trans "Duplicate products" %}</th>
+                  <th>{% trans "Unknown products" %}</th>
+                  <th>{% trans "Date uploaded" %}</th>
+                </tr>
+              </thead>
+              <tbody>
+                {% for upload in uploads %}
+                  <tr>
+                    <td>{{ upload.filepath }}</td>
+                    <td>{{ upload.num_new_skus }}</td>
+                    <td>{{ upload.num_duplicate_skus }}</td>
+                    <td>{{ upload.num_unknown_skus }}</td>
+                    <td>{{ upload.date_uploaded }}</td>
+                  </tr>
+                {% endfor %}
+              </tbody>
+            </table>
+          {% endif %}
+          {% endwith %}
+
+          {% if range.excluded_products.count %}
+            <form method="post">
+              {% csrf_token %}
+              <table class="table table-striped table-bordered table-hover">
+               <caption>
+                  <h3 class="float-left">{% trans "Products excluded from range" %}</h3>
+                  <div class="float-right">
+                    <input type="hidden" name="action" value="remove_excluded_products" />
+                    <button type="submit" class="btn btn-secondary" data-loading-text="{% trans 'Removing...' %}">
+                      {% trans "Remove selected excluded products" %}
+                    </button>
+                  </div>
+                </caption>
+                <thead>
+                  <tr>
+                    <th></th>
+                    <th>{% trans "UPC" %}</th>
+                    <th>{% trans "Title" context "Product title" %}</th>
+                    <th>{% trans "Is product discountable?" %}</th>
+                    <th></th>
+                  </tr>
+                </thead>
+                <tbody class="product_list">
+                  {% for product in range.excluded_products.all %}
+                    <tr id="product_{{ product.pk }}">
+                      <td>
+                        <input type="checkbox" name="selected_product" value="{{ product.id }}" />
+                      </td>
+                      <td>{{ product.upc|default:"-" }}</td>
+                      <td><a href="{% url 'dashboard:catalogue-product' pk=product.id %}">{{ product.get_title }}</a></td>
+                      <td>{% if product.get_is_discountable %}{% trans "Yes" %}{% else %}{% trans "No" %}{% endif %}</td>
+                      <td><a class="btn btn-danger" href="#" data-behaviours="remove">{% trans "Remove" %}</a></td>
+                    </tr>
+                  {% endfor %}
+                </tbody>
+              </table>
+            </form>
+
+          {% else %}
+            <table class="table table-striped table-bordered table-hover">
+              <caption>
+                {% trans "Products excluded from Range" %}
+              </caption>
+              <tr><td>{% trans "No products found." %}</td></tr>
+            </table>
+          {% endif %}
+
+        </div>
+
+    </div>
+
+  </div>
+
+</div>
+
+<div class="form-actions">
+  <a href="{% url 'dashboard:range-update' pk=range.id %}" class="btn btn-primary">{% trans "Edit range" %}</a> {% trans "or" %}
+  <a href="{% url 'dashboard:range-list' %}" class="">{% trans "return to range list" %}</a>
+</div>
+
 {% endblock dashboard_content %}
 
 {% block onbodyload %}

tests/functional/dashboard/test_range.py

 
     def test_upload_file_with_skus(self):
         range_products_page = self.get(self.url)
-        form = range_products_page.form
+        form = range_products_page.forms[0]
         form['file_upload'] = Upload('new_skus.txt', b'456')
         form.submit().follow()
         all_products = self.range.all_products()
         range_product_file_upload = RangeProductFileUpload.objects.get()
         self.assertEqual(range_product_file_upload.range, self.range)
         self.assertEqual(range_product_file_upload.num_new_skus, 1)
-        self.assertEqual(range_product_file_upload.status, RangeProductFileUpload.PROCESSED)
+        self.assertEqual(range_product_file_upload.status,
+                         RangeProductFileUpload.PROCESSED)
         self.assertEqual(range_product_file_upload.size, 3)
 
+    def test_upload_excluded_file_with_skus(self):
+        excluded_products = self.range.excluded_products.all()
+        self.assertEqual(len(excluded_products), 0)
+        self.assertFalse(self.product3 in excluded_products)
+
+        # Upload the product
+        range_products_page = self.get(self.url)
+        form = range_products_page.forms[1]
+        form['file_upload'] = Upload('new_skus.txt', b'456')
+        form.submit().follow()
+
+        excluded_products = self.range.excluded_products.all()
+        self.assertEqual(len(excluded_products), 1)
+        self.assertTrue(self.product3 in excluded_products)
+
+        range_product_file_upload = RangeProductFileUpload.objects.get()
+        self.assertEqual(range_product_file_upload.range, self.range)
+        self.assertEqual(range_product_file_upload.num_new_skus, 1)
+        self.assertEqual(range_product_file_upload.status,
+                         RangeProductFileUpload.PROCESSED)
+        self.assertEqual(range_product_file_upload.size, 3)
+
+    def test_upload_multiple_excluded_file_with_skus(self):
+        excluded_products = self.range.excluded_products.all()
+        self.assertEqual(len(excluded_products), 0)
+        self.assertFalse(self.product3 in excluded_products)
+        self.assertFalse(self.product4 in excluded_products)
+
+        # Upload the products
+        range_products_page = self.get(self.url)
+        form = range_products_page.forms[1]
+        form['file_upload'] = Upload('new_skus.txt', b'456,789')
+        form.submit().follow()
+
+        excluded_products = self.range.excluded_products.all()
+        self.assertEqual(len(excluded_products), 2)
+        self.assertTrue(self.product3 in excluded_products)
+        self.assertTrue(self.product4 in excluded_products)
+
+        range_product_file_upload = RangeProductFileUpload.objects.get()
+        self.assertEqual(range_product_file_upload.range, self.range)
+        self.assertEqual(range_product_file_upload.num_new_skus, 2)
+        self.assertEqual(range_product_file_upload.status,
+                         RangeProductFileUpload.PROCESSED)
+        self.assertEqual(range_product_file_upload.size, 7)
+
+    def test_exclude_skus_textarea_form_field(self):
+        excluded_products = self.range.excluded_products.all()
+        self.assertEqual(len(excluded_products), 0)
+        self.assertFalse(self.product3 in excluded_products)
+
+        range_products_page = self.get(self.url)
+        form = range_products_page.forms[1]
+        form['query'] = '456'
+        form.submit().follow()
+
+        excluded_products = self.range.excluded_products.all()
+        self.assertEqual(len(excluded_products), 1)
+        self.assertTrue(self.product3 in excluded_products)
+
+    def test_exclude_multiple_skus_textarea_form_field(self):
+        excluded_products = self.range.excluded_products.all()
+        self.assertEqual(len(excluded_products), 0)
+        self.assertFalse(self.product3 in excluded_products)
+        self.assertFalse(self.product4 in excluded_products)
+
+        range_products_page = self.get(self.url)
+        form = range_products_page.forms[1]
+        form['query'] = '456,789'
+        form.submit().follow()
+
+        excluded_products = self.range.excluded_products.all()
+        self.assertEqual(len(excluded_products), 2)
+        self.assertTrue(self.product3 in excluded_products)
+        self.assertTrue(self.product4 in excluded_products)
+
     def test_dupe_skus_warning(self):
         self.range.add_product(self.product3)
         range_products_page = self.get(self.url)
         self.assertEqual(list(response.context['messages']), [])
         self.assertEqual(
             response.context['form'].errors['query'],
-            ['The products with SKUs or UPCs matching 456 are already in this range']
+            ['The products with SKUs or UPCs matching 456 have already been added to this range']
         )
 
         form = response.forms[0]
         messages = list(response.context['messages'])
         self.assertEqual(len(messages), 2)
         self.assertEqual(messages[0].level, SUCCESS)
-        self.assertEqual(messages[0].message, '1 product added to range')
+        self.assertEqual(messages[0].message, '1 product has been added to this range')
+        self.assertEqual(messages[1].level, WARNING)
+        self.assertEqual(
+            messages[1].message,
+            'The products with SKUs or UPCs matching 456 have already been added to this range'
+        )
+
+    def test_dupe_excluded_skus_warning(self):
+        self.range.add_product(self.product3)
+        self.range.add_product(self.product4)
+        self.range.excluded_products.add(self.product3)
+        range_products_page = self.get(self.url)
+        form = range_products_page.forms[2]
+        form['query'] = '456'
+        response = form.submit()
+        self.assertEqual(list(response.context['messages']), [])
+        self.assertEqual(
+            response.context['form_excluded'].errors['query'],
+            ['The products with SKUs or UPCs matching 456 have already been excluded from this range']
+        )
+
+        form = response.forms[2]
+        form['query'] = '456, 789'
+        response = form.submit().follow()
+        messages = list(response.context['messages'])
+        self.assertEqual(len(messages), 2)
+        self.assertEqual(messages[0].level, SUCCESS)
+        self.assertEqual(messages[0].message, '1 product has been excluded from this range')
         self.assertEqual(messages[1].level, WARNING)
         self.assertEqual(
             messages[1].message,
-            'The products with SKUs or UPCs matching 456 are already in this range'
+            'The products with SKUs or UPCs matching 456 have already been excluded from this range'
         )
 
     def test_missing_skus_warning(self):
         range_products_page = self.get(self.url)
-        form = range_products_page.form
+        form = range_products_page.forms[0]
         form['query'] = '321'
         response = form.submit()
         self.assertEqual(list(response.context['messages']), [])
             response.context['form'].errors['query'],
             ['No products exist with a SKU or UPC matching 321']
         )
-        form = range_products_page.form
+        form = range_products_page.forms[0]
         form['query'] = '456, 321'
         response = form.submit().follow()
         messages = list(response.context['messages'])
         self.assertEqual(len(messages), 2)
         self.assertEqual(messages[0].level, SUCCESS)
-        self.assertEqual(messages[0].message, '1 product added to range')
+        self.assertEqual(messages[0].message, '1 product has been added to this range')
         self.assertEqual(messages[1].level, WARNING)
         self.assertEqual(
             messages[1].message, 'No product(s) were found with SKU or UPC matching 321'
 
     def test_same_skus_within_different_products_warning_query(self):
         range_products_page = self.get(self.url)
-        form = range_products_page.form
+        form = range_products_page.forms[0]
         form['query'] = '123123'
         response = form.submit().follow()
         messages = list(response.context['messages'])
 
     def test_same_skus_within_different_products_warning_file_upload(self):
         range_products_page = self.get(self.url)
-        form = range_products_page.form
+        form = range_products_page.forms[0]
         form['file_upload'] = Upload('skus.txt', b'123123')
         response = form.submit().follow()
         messages = list(response.context['messages'])
         self.assertTrue(self.range.contains_product(self.child2))
         self.assertFalse(self.range.contains_product(self.parent))
 
+    def test_remove_selected_product(self):
+        self.range.add_product(self.product3)
+        range_products_page = self.get(self.url)
+        form = range_products_page.forms[1]
+        form['selected_product'] = '456'
+        response = form.submit().follow()
+        messages = list(response.context['messages'])
+        self.assertEqual(len(messages), 1)
+        self.assertEqual(messages[0].level, SUCCESS)
+        self.assertEqual(messages[0].message, 'Removed 1 product from range')
+        self.assertFalse(self.range.contains_product(self.product3))
+        self.assertTrue(self.product3 in self.range.excluded_products.all())
+
+    def test_remove_excluded_product(self):
+        self.range.add_product(self.product3)
+        self.range.excluded_products.add(self.product3)
+        self.assertFalse(self.range.contains_product(self.product3))
+
+        # Remove the product from exclusion form
+        range_products_page = self.get(self.url)
+        form = range_products_page.forms[2]
+        form['selected_product'] = '456'
+        response = form.submit().follow()
+
+        messages = list(response.context['messages'])
+        self.assertEqual(len(messages), 1)
+        self.assertEqual(messages[0].level, SUCCESS)
+        self.assertEqual(messages[0].message, 'Removed 1 product from excluded list')
+        self.assertTrue(self.range.contains_product(self.product3))
+
+    def test_remove_multiple_excluded_products(self):
+        self.test_upload_multiple_excluded_file_with_skus()
+        self.assertIn(self.product3, self.range.excluded_products.all())
+        self.assertIn(self.product4, self.range.excluded_products.all())
+
+        range_products_page = self.get(self.url)
+        form = range_products_page.forms[2]
+        form['selected_product'] = [self.product3.pk, self.product4.pk]
+        response = form.submit().follow()
+
+        messages = list(response.context['messages'])
+        self.assertEqual(len(messages), 1)
+        self.assertEqual(messages[0].level, SUCCESS)
+        self.assertEqual(messages[0].message, 'Removed 2 products from excluded list')
+        self.assertNotIn(self.product3, self.range.excluded_products.all())
+        self.assertNotIn(self.product4, self.range.excluded_products.all())
+
 
 class RangeReorderViewTest(WebTestCase):
     is_staff = True