Merge pull request #1 from aptivate/use_api_to_list_terms

Use api to list terms

django/website/hid/templates/hid/categories_column.html

@@ -4,7 +4,7 @@
             <option value="" selected="selected">---------</option>
         {% endif %}
         {% for cat in categories %}
-        <option value="{{ cat.0 }}"{% if category == cat.0 %} selected="selected"{% endif %}>{{ cat.0 }}</option>
+        <option value="{{ cat.0 }}"{% if category == cat.0 %} selected="selected"{% endif %}>{{ cat.1 }}</option>
         {% endfor %}
     </select>
 {% endif %}

django/website/hid/tests/views_tests.py

@@ -128,11 +128,11 @@ def test_get_category_options_uses_terms():
     )
 
     view = ViewItems()
-    options = view.get_category_options(ebola_questions.id)
+    options = view.get_category_options(ebola_questions.slug)
 
-    assert (type_1.name, type_1.long_name) in options
-    assert (type_2.name, type_2.long_name) in options
-    assert (type_3.name, type_3.long_name) in options
+    assert (type_1.name, type_1.name) in options
+    assert (type_2.name, type_2.name) in options
+    assert (type_3.name, type_3.name) in options
     assert (other_term.name, other_term.long_name) not in options
 
 
@@ -154,14 +154,14 @@ def test_get_category_options_with_no_taxonomy_returns_all():
     view = ViewItems()
     options = view.get_category_options()
 
-    assert (type_1.name, type_1.long_name) in options
-    assert (other_term.name, other_term.long_name) in options
+    assert (type_1.name, type_1.name) in options
+    assert (other_term.name, other_term.name) in options
 
 
 @pytest.mark.django_db
 def test_get_category_options_orders_by_lowercase_name():
     # TODO: Rewrite tests to use transport layer
-    ebola_questions = TaxonomyFactory(name="Ebola Questions")
+    taxonomy = TaxonomyFactory(name="order_by_lowercase_name_test")
     test_term_values = [
         ('test a1', '1'), ('test b1', '2'),
         ('test A2', '3'), ('test B2', '4')
@@ -170,16 +170,15 @@ def test_get_category_options_orders_by_lowercase_name():
         TermFactory(
             name=test_value[0],
             long_name=test_value[1],
-            taxonomy=ebola_questions
+            taxonomy=taxonomy
         )
 
     view = ViewItems()
-    options = view.get_category_options(ebola_questions.id)
-    # Make sure we are only comparing with out test values!
-    options = [o for o in options if o in test_term_values]
+    options = view.get_category_options(taxonomy.slug)
 
     # Expected is the list ordered by lowercase short name.
-    expected = sorted(test_term_values, key=lambda e: e[0].lower())
+    expected = [(short, short) for short, long_name in test_term_values]
+    expected = tuple(sorted(expected, key=lambda e: e[0].lower()))
 
     assert options == expected
 

django/website/hid/views.py

@@ -14,7 +14,6 @@ from django.views.generic.base import TemplateView
 from django_tables2 import SingleTableView
 
 from chn_spreadsheet.importer import Importer, SheetImportException
-from data_layer.models import Term
 import transport
 from transport.exceptions import TransportException
 from .assets import require_assets
@@ -90,26 +89,18 @@ class ViewItems(SingleTableView):
     def get_queryset(self):
         return transport.items.list()
 
-    def get_category_options(self, categories_id=None):
-        # TODO: Use data layer
-        terms = self.get_matching_terms(categories_id)
-        return tuple((t.name, t.long_name) for t in terms)
-
-    def get_matching_terms(self, categories_id):
-        if categories_id is None:
-            return (Term.objects
-                    .extra(select={'name_lower': 'lower(name)'})
-                    .order_by('name_lower')
-                    .all())
-
-        return (Term.objects
-                .extra(select={'name_lower': 'lower(name)'})
-                .order_by('name_lower')
-                .filter(taxonomy__id=categories_id))
+    def get_category_options(self, taxonomy_slug=None):
+        if taxonomy_slug is not None:
+            terms = transport.terms.list(taxonomy=taxonomy_slug)
+        else:
+            terms = transport.terms.list()
+        terms.sort(key=lambda e: e['name'].lower())
+        return tuple((t['name'], t['name']) for t in terms)
 
     def get_table(self, **kwargs):
-        # TODO: Filter on taxonomy
-        kwargs['categories'] = self.get_category_options()
+        kwargs['categories'] = self.get_category_options(
+            QUESTION_TYPE_TAXONOMY
+        )
         return super(ViewItems, self).get_table(**kwargs)
 
     def get_context_data(self, **kwargs):
@@ -126,9 +117,7 @@ class ViewItems(SingleTableView):
             ),
             self._build_action_dropdown_group(
                 label=_('Set question type'),
-                items=[(short_name, short_name)
-                       for short_name, long_name
-                       in self.get_category_options()],
+                items=self.get_category_options(QUESTION_TYPE_TAXONOMY),
                 prefix=ADD_CATEGORY_PREFIX
             )
         ]

django/website/rest_api/views.py

@@ -92,4 +92,32 @@ class TaxonomyViewSet(viewsets.ModelViewSet):
 class TermViewSet(viewsets.ModelViewSet):
     serializer_class = TermSerializer
 
-    queryset = Term.objects.all()  # Will need to filter by taxonomy eventually
+    queryset = Term.objects.all()
+
+    def get_queryset(self):
+        """ Return the query set to fetch terms.
+
+        The request may contain the following
+        exact match filters:
+            name: Name of the term
+            long_name: Long name of the term
+            taxonomy: Slug of the term's taxonomy
+
+        Returns:
+            QuerySet: A query set
+        """
+        items = Term.objects.all()
+
+        name = self.request.query_params.get('name', None)
+        if name is not None:
+            items = items.filter(name=name)
+
+        long_name = self.request.query_params.get('long_name', None)
+        if long_name is not None:
+            items = items.filter(long_name=long_name)
+
+        taxonomy_slug = self.request.query_params.get('taxonomy', None)
+        if taxonomy_slug is not None:
+            items = items.filter(taxonomy__slug=taxonomy_slug)
+
+        return items

django/website/taxonomies/tests/factories.py

@@ -19,7 +19,7 @@ class TermFactory(DjangoModelFactory):
 
     class Meta:
         model = Term
-        django_get_or_create = ('name',)
+        django_get_or_create = ('name', 'taxonomy')
 
     name = fuzzy.FuzzyText()
 

django/website/transport/__init__.py

 import items
 import taxonomies
+import terms
 
-__all__ = ['items', 'taxonomies', ]
+__all__ = ['items', 'taxonomies', 'terms']

django/website/transport/terms.py

+from django.core.urlresolvers import reverse
+
+from rest_api.views import TermViewSet
+from rest_framework.test import APIRequestFactory
+from rest_framework import status
+
+from .exceptions import TransportException
+
+
+request_factory = APIRequestFactory()
+
+
+def list_url():
+    """ Returns the url to obtain the list of terms
+
+    Returns:
+        str: List of term URL
+    """
+    return reverse('term-list')
+
+
+def get_view(actions):
+    """ Return the view to perform the given action.
+
+    Args:
+        actions (dict): Dictionary of actions, eg.
+            {'get': 'list'}
+    Returns:
+        View: A view object
+    """
+    return TermViewSet.as_view(actions)
+
+
+def list(**kwargs):
+    """ Return a list of Terms
+
+    If keyword arguments are given, they are used
+    to filter the terms. This can be used to list
+    the terms in a given taxonomy.
+
+    Args:
+        **kwargs: Filters
+    Returns:
+        list: List of terms
+    Raises:
+        TransportException: On transport failure.
+            'status_code' is set to the response
+            status code.
+    """
+    view = get_view(actions={'get': 'list'})
+    request = request_factory.get(list_url(), kwargs)
+    response = view(request)
+
+    if not status.is_success(response.status_code):
+        response.data['status_code'] = response.status_code
+        raise TransportException(response.data)
+
+    return response.data

django/website/transport/tests/term_list_tests.py

+from __future__ import unicode_literals, absolute_import
+import pytest
+
+from taxonomies.tests.factories import TaxonomyFactory, TermFactory
+import transport
+
+
+@pytest.mark.django_db
+def test_list_terms_returns_terms():
+    taxonomy = TaxonomyFactory(name='A test taxonomy')
+    term = TermFactory(name="A test term", taxonomy=taxonomy)
+
+    terms = transport.terms.list()
+    terms_as_items = [t.items() for t in terms]
+
+    expected = {
+        'taxonomy': taxonomy.slug,
+        'name': term.name,
+        'long_name': term.long_name
+    }.items()
+
+    assert expected in terms_as_items
+
+
+@pytest.mark.django_db
+def test_list_terms_applies_taxonomy_filter():
+    taxonomy = TaxonomyFactory(name='A test taxonomy')
+    term = TermFactory(name="A test term", taxonomy=taxonomy)
+    term_2 = TermFactory(name="A second test term", taxonomy=taxonomy)
+    taxonomy_2 = TaxonomyFactory(name='Another test taxonomy')
+    TermFactory(name="A third test term", taxonomy=taxonomy_2)
+
+    terms = transport.terms.list(taxonomy=taxonomy.slug)
+    terms_as_items = [t.items() for t in terms]
+
+    expected = [t.items() for t in [
+        {
+            'taxonomy': taxonomy.slug,
+            'name': term.name,
+            'long_name': term.long_name
+        },
+        {
+            'taxonomy': taxonomy.slug,
+            'name': term_2.name,
+            'long_name': term_2.long_name
+        }
+
+    ]]
+
+    assert len(terms) == 2
+    assert sorted(terms_as_items) == sorted(expected)
+
+
+@pytest.mark.django_db
+def test_list_terms_applies_name_filter_accross_taxonomies():
+    taxonomy = TaxonomyFactory(name='A test taxonomy')
+    term = TermFactory(name="A test term", taxonomy=taxonomy)
+    TermFactory(name="Another test term", taxonomy=taxonomy)
+    taxonomy_2 = TaxonomyFactory(name='Another test taxonomy')
+    term_2 = TermFactory(name="A test term", taxonomy=taxonomy_2)
+
+    terms = transport.terms.list(name="A test term")
+    terms_as_items = [t.items() for t in terms]
+
+    expected = [t.items() for t in [
+        {
+            'taxonomy': taxonomy.slug,
+            'name': term.name,
+            'long_name': term.long_name
+        },
+        {
+            'taxonomy': taxonomy_2.slug,
+            'name': term_2.name,
+            'long_name': term_2.long_name
+        }
+    ]]
+
+    assert len(terms) == 2
+    assert sorted(terms_as_items) == sorted(expected)