From 222fc528bcb62e2f599e97fb09bf216ff34cf91e Mon Sep 17 00:00:00 2001
From: Alan Crosswell <alan@columbia.edu>
Date: Wed, 21 Mar 2018 18:51:03 -0400
Subject: [PATCH 1/6] WIP: Improvements for pagination, sorting, filtering, and
 exception handling

* Pagination updates:
  * Improve existing documentation of pagination, mixins
    * Document LimitOffsetPagination
    * Describe how to override pagination class query parameter names.
    * Remove reference to PAGINATE_BY_PARAM which was deprecated in DRF 3.2.
    * Document SparseFieldsetsMixin
  * Add new default settings for pagination query parameters and maximum size.
* Add combinable mixins for filter and sort query parameters and make MultiplIDMixin combinable.
* Exceptions updates:
  * Document JSON_API_UNIFORM_EXCEPTIONS setting.
  * handle missing fields exception thrown by new filter and sort Mixins as a 400 error.
  * Catch all exceptions not caught by DRF and format as JSON API error objects instead of returning HTML error pages.
---
 CHANGELOG.md                          | 14 ++++
 docs/api.md                           | 64 +++++++++++++++++-
 docs/usage.md                         | 95 +++++++++++++++++++++++++--
 rest_framework_json_api/exceptions.py | 47 ++++++++++++-
 rest_framework_json_api/mixins.py     | 72 +++++++++++++++++++-
 rest_framework_json_api/pagination.py | 17 +++--
 6 files changed, 293 insertions(+), 16 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index dc2b441f..7d7bf297 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,17 @@
+v2.4.x - [Unreleased]
+* Pagination updates:
+  * Improve existing documentation of pagination, mixins
+    * Document LimitOffsetPagination
+    * Describe how to override pagination class query parameter names.
+    * Remove reference to PAGINATE_BY_PARAM which was deprecated in DRF 3.2.
+    * Document SparseFieldsetsMixin
+  * Add new default settings for pagination query parameters and maximum size.
+* Add combinable mixins for filter and sort query parameters and make MultiplIDMixin combinable.
+* Exceptions updates:
+  * Document JSON_API_UNIFORM_EXCEPTIONS setting.
+  * handle missing fields exception thrown by new filter and sort Mixins as a 400 error.
+  * Catch all exceptions not caught by DRF and format as JSON API error objects instead of returning HTML error pages.
+  
 v2.4.0 - Released January 25, 2018
 
 * Add support for Django REST Framework 3.7.x.
diff --git a/docs/api.md b/docs/api.md
index 86116d5c..760f2421 100644
--- a/docs/api.md
+++ b/docs/api.md
@@ -4,9 +4,71 @@
 ## mixins
 ### MultipleIDMixin
 
-Add this mixin to a view to override `get_queryset` to automatically filter
+Add this mixin to a view to override `get_queryset` to filter
 records by `ids[]=1&ids[]=2` in URL query params.
 
+For example:
+```http request
+GET /widgets/?ids[]=123&ids[]=456
+```
+
+You might want to consider using the `FilterMixin` where the equivalent example is:
+```http request
+GET /widgets/?filter[id]=123,456
+```
+
+### FilterMixin
+
+This ViewSet mixin augments `get_queryset` to provide JSON API filter query parameter support
+per the [recommendation](http://jsonapi.org/recommendations/#filtering).
+
+The `filter` syntax is `filter[name1]=list,of,alternative,values&filter[name2]=more,alternatives...`
+which can be interpreted as `(name1 in [list,of,alternative,values]) and (name2 in [more,alternatives])`
+`name` can be `id` or attributes fields.
+
+For example:
+
+```http request
+GET /widgets/?filter[name]=can+opener,tap&filter[color]=red
+```
+
+### SortMixin
+
+This ViewSet mixin augments `get_queryset` to provide JSON API sort query parameter support
+per the [recommendation](http://jsonapi.org/format/#fetching-sorting).
+
+The `sort` syntax is `sort=-field1,field2,...`
+
+For example:
+
+```http request
+GET /widgets/?sort=-name,color
+```
+
+### SparseFieldsetsMixin
+
+This Serializer mixin implements [sparse fieldsets](http://jsonapi.org/format/#fetching-sparse-fieldsets)
+with the `fields[type]=` parameter. It is included by default in the HyperLinkedModelSerializer and
+ModelSerializer classes.
+
+For example:
+
+```http request
+GET /widgets/?fields[widgets]=name
+``` 
+
+### IncludedResourcesValidationMixin
+
+This Serializer mixin implements [included compound documents](http://jsonapi.org/format/#document-compound-documents)
+with the `include=` parameter. It is included by default in the HyperLinkedModelSerializer and
+ModelSerializer classes. 
+
+For example:
+
+```http request
+GET /widgets/?included=locations
+```
+
 ## rest_framework_json_api.renderers.JSONRenderer
 
 The `JSONRenderer` exposes a number of methods that you may override if you need
diff --git a/docs/usage.md b/docs/usage.md
index 7b0b6cc0..8e1bd3d5 100644
--- a/docs/usage.md
+++ b/docs/usage.md
@@ -34,14 +34,73 @@ REST_FRAMEWORK = {
 }
 ```
 
-If `PAGE_SIZE` is set the renderer will return a `meta` object with
+### Pagination settings
+
+If `REST_FRAMEWORK['PAGE_SIZE']` is set the renderer will return a `meta` object with
 record count and a `links` object with the next, previous, first, and last links.
-Pages can be selected with the `page` GET parameter. The query parameter used to
-retrieve the page can be customized by subclassing `PageNumberPagination` and
-overriding the `page_query_param`.  Page size can be controlled per request via
-the `PAGINATE_BY_PARAM` query parameter (`page_size` by default).
 
-#### Performance Testing
+#### Subclassing paginators
+
+The JSON API pagination classes can be subclassed to override settings as
+described in the [DRF pagination documentation](http://www.django-rest-framework.org/api-guide/pagination/).
+
+The default values are shown in these examples:
+
+```python
+from rest_framework_json_api.pagination import PageNumberPagination, LimitOffsetPagination
+
+class MyPagePagination(PageNumberPagination):
+    page_query_param = 'page'
+    page_size_query_param = 'page_size'
+    max_page_size = 100
+
+class MyLimitPagination(LimitOffsetPagination):
+    offset_query_param = 'page[offset]'
+    limit_query_param = 'page[limit]'
+    max_limit = None
+```
+
+As shown above, pages can be selected with the `page` or `page[limit]` GET query parameter when using
+the PageNumberPagination or LimitOffsetPagination class, respectively. 
+
+If you want to use the PageNumberPagination query parameter names shown
+as an example in the JSON API [specification](http://jsonapi.org/format/#fetching-pagination),
+set them as follows:
+```python
+class MyPagePagination(PageNumberPagination):
+    page_query_param = 'page[number]'
+    page_size_query_param = 'page[size]'
+```
+
+#### Setting global defaults for pagination
+
+Set global defaults for the `PageNumberPagination` class with these settings:
+- `JSON_API_PAGE_NUMBER_PARAM` sets the name of the page number query parameter (default: "page").
+- `JSON_API_PAGE_SIZE_PARAM` sets the name of the page size query parameter (default: "page_size").
+- `JSON_API_MAX_PAGE_SIZE` sets an upper limit for the page size query parameter (default: 100).
+
+Set global defaults for the `LimitOffsetPagination` class with these settings:
+- `JSON_API_PAGE_OFFSET_PARAM` sets the name of the page offset query parameter (default: "page\[offset\]").
+- `JSON_API_PAGE_LIMIT_PARAM` sets the name of the page limit query parameter (default: "page\[limit\]").
+- `JSON_API_MAX_PAGE_LIMIT` sets an upper limit for the page limit query parameter (default: None).
+
+If you want to set the default PageNumberPagination query parameter names shown
+as an example in the JSON API [specification](http://jsonapi.org/format/#fetching-pagination),
+set them as follows:
+```python
+JSON_API_PAGE_NUMBER_PARAM = 'page[number]'
+JSON_API_PAGE_SIZE_PARAM = 'page[size]'
+```
+
+### Exception handling
+
+For the `exception_handler` class, if the optional `JSON_API_UNIFORM_EXCEPTIONS` is set to True,
+all exceptions will respond with the JSON API [error format](http://jsonapi.org/format/#error-objects).
+
+When `JSON_API_UNIFORM_EXCEPTIONS` is False (the default), non-JSON API views will respond
+with the normal DRF error format.
+
+### Performance Testing
 
 If you are trying to see if your viewsets are configured properly to optimize performance,
 it is preferable to use `example.utils.BrowsableAPIRendererWithoutForms` instead of the default `BrowsableAPIRenderer`
@@ -606,6 +665,30 @@ with 1e18 rows which will likely exhaust any available memory and
 slow your database to crawl.
 
 The prefetch_related case will issue 4 queries, but they will be small and fast queries.
+
+### Filtering and Sorting views and viewsets
+
+To add JSON API-style [filtering](http://jsonapi.org/recommendations/#filtering)
+or [sorting](http://jsonapi.org/format/#fetching-sorting) query parameters for GET requests,
+add the FilterMixin or SortMixin to a view or viewset. For example:
+
+```python
+from djangorestframework_jsonapi.mixins import FilterMixin, SortMixin
+from rest_framework_json_api.views import viewsets
+
+class WidgetViewSet(SortMixin, FilterMixin, viewsets.ModelViewSet):
+    queryset = Widget.objects.all()
+    serializer_class = WidgetSerializer
+```
+
+### Sparse Fieldsets
+
+The HyperlinkedModelSerializer already includes the mixin for the
+`field[type]=attr1,attr2,...` parameter 
+([sparse fieldsets](http://jsonapi.org/format/#fetching-sparse-fieldsets)).
+
+
+
 <!--
 ### Relationships
 ### Errors
diff --git a/rest_framework_json_api/exceptions.py b/rest_framework_json_api/exceptions.py
index f6b21ad6..69eebdb1 100644
--- a/rest_framework_json_api/exceptions.py
+++ b/rest_framework_json_api/exceptions.py
@@ -1,10 +1,11 @@
 from django.conf import settings
 from django.utils.translation import ugettext_lazy as _
 from rest_framework import exceptions, status
-
+import re
+from rest_framework.response import Response
+from django.core.exceptions import FieldDoesNotExist, FieldError
 from rest_framework_json_api import utils
 
-
 def rendered_with_json_api(view):
     from rest_framework_json_api.renderers import JSONRenderer
     for renderer_class in getattr(view, 'renderer_classes', []):
@@ -12,6 +13,46 @@ def rendered_with_json_api(view):
             return True
     return False
 
+def unhandled_drf_exception_handler(exc, context):
+    """
+    Deals with exceptions that DRF doesn't catch, specifically for filter & sort query parameters:
+    "Cannot resolve keyword 'xname' into field. Choices are: name, title, ...."
+
+    Even a 500 error for a jsonapi view should return a jsonapi error object, not an HTML response.
+    """
+    if not rendered_with_json_api(context['view']):
+        return None
+    keymatch = re.compile(r"^Cannot resolve keyword '(?P<keyword>\w+)' into field.")
+    if isinstance(exc, (FieldError, FieldDoesNotExist,)):
+        matched = keymatch.match(str(exc))
+        bad_kw = matched.group("keyword") if matched else "?"
+        status_code = 400
+        errors = [
+            {
+                "status": status_code,
+                "code": "field_error",
+                "title": "Field error",
+                "detail": str(exc),
+                "source": {
+                    "pointer": context["request"].path,
+                    "parameter": bad_kw
+                }
+            }
+        ]
+    else:
+        status_code = 500
+        errors = [
+            {
+                "status": 500,
+                "code": "server_error",
+                "title": "Internal Server Error",
+                "detail": str(exc),
+                "source": {
+                    "pointer": context["request"].path,
+                }
+            }
+        ]
+    return Response(errors, status=status_code)
 
 def exception_handler(exc, context):
     # Import this here to avoid potential edge-case circular imports, which
@@ -25,7 +66,7 @@ def exception_handler(exc, context):
     # Render exception with DRF
     response = drf_exception_handler(exc, context)
     if not response:
-        return response
+        return unhandled_drf_exception_handler(exc, context)
 
     # Use regular DRF format if not rendered by DRF JSON API and not uniform
     is_json_api_view = rendered_with_json_api(context['view'])
diff --git a/rest_framework_json_api/mixins.py b/rest_framework_json_api/mixins.py
index 7b98d62e..7166bbe5 100644
--- a/rest_framework_json_api/mixins.py
+++ b/rest_framework_json_api/mixins.py
@@ -5,13 +5,14 @@
 
 class MultipleIDMixin(object):
     """
-    Override get_queryset for multiple id support
+    A stackable Mixin that overides get_queryset for multiple id support
     """
 
     def get_queryset(self):
         """
         Override :meth:``get_queryset``
         """
+        self.queryset = super(MultipleIDMixin, self).get_queryset()
         if hasattr(self.request, 'query_params'):
             ids = dict(self.request.query_params).get('ids[]')
         else:
@@ -19,3 +20,72 @@ def get_queryset(self):
         if ids:
             self.queryset = self.queryset.filter(id__in=ids)
         return self.queryset
+
+
+class FilterMixin(object):
+    """
+    A stackable Mixin that overrides get_queryset for JSON API filter query parameter support
+    per http://jsonapi.org/recommendations/#filtering.
+
+    The `filter` syntax is `filter[name1]=list,of,alternative,values&filter[name2]=more,alternatives...`
+    which can be interpreted as `(name1 in [list,of,alternative,values]) and (name2 in [more,alternatives])`
+    `name` can be `id` or attributes field.
+
+    @example
+    GET /widgets/?filter[name1]=can+opener,tap&filter[name2]=foo
+
+    TODO: decide if we want to allow multiple instances of the *same* filter[field]
+      e.g. Is "&filter[id]==123&filter[id]=345" the same as "&filter[id]=123,345"?
+      For now additional instances of the same filter[field] are ignored.
+    """
+
+    def get_queryset(self):
+        """
+        Override :meth:``get_queryset``
+        """
+        self.queryset = super(FilterMixin, self).get_queryset()
+        qp = dict(self.request.query_params if hasattr(self.request, 'query_params') else self.request.QUERY_PARAMS)
+        if not qp:
+            return self.queryset
+        FILTER = 'filter['
+        flen = len(FILTER)
+        filters = {}
+        for k in qp:
+            if k[:flen] == FILTER and k[-1] == ']':
+                attr = k[flen:-1]
+                filters[attr+"__in"] = qp.get(k)[0].split(',')
+
+        self.queryset = self.queryset.filter(**filters)
+        return self.queryset
+
+
+class SortMixin(object):
+    """
+    A stackable Mixin that overrides get_queryset for JSON API sort query parameter support
+    per http://jsonapi.org/format/#fetching-sorting.
+
+    The `sort` syntax is `sort=-field1,field2,...`
+    The `sort` parameter is allowed to be given more than once and the lists are combined.
+    e.g. "&sort=field1&sort=field2" is the same as "&sort=field1,field2".
+    TODO: Decide if allowing repeats of the sort parameter is correct.
+    TODO: Add dot-separated type.field to enable sorting by relationship attributes.
+
+    @example
+    GET /widgets/?sort=-name1,name2&sort=name3,name4
+    """
+
+    def get_queryset(self):
+        """
+        Override :meth:``get_queryset``
+        """
+        self.queryset = super(SortMixin, self).get_queryset()
+        qp = dict(self.request.query_params if hasattr(self.request, 'query_params') else self.request.QUERY_PARAMS)
+        if not qp:
+            return self.queryset
+        sorts = []
+        if 'sort' in qp:
+            for s in qp.get('sort'):
+                sorts += s.split(',')
+
+        self.queryset = self.queryset.order_by(*sorts)
+        return self.queryset
diff --git a/rest_framework_json_api/pagination.py b/rest_framework_json_api/pagination.py
index f36cdfe6..bc02cb05 100644
--- a/rest_framework_json_api/pagination.py
+++ b/rest_framework_json_api/pagination.py
@@ -7,14 +7,17 @@
 from rest_framework.utils.urls import remove_query_param, replace_query_param
 from rest_framework.views import Response
 
+from django.conf import settings
+
 
 class PageNumberPagination(PageNumberPagination):
     """
     A json-api compatible pagination format
+    TODO: Consider changing defaults to page[number] and page[size]. This would be a breaking change.
     """
-
-    page_size_query_param = 'page_size'
-    max_page_size = 100
+    page_query_param = getattr(settings, 'JSON_API_PAGE_NUMBER_PARAM', 'page')
+    page_size_query_param = getattr(settings, 'JSON_API_PAGE_SIZE_PARAM', 'page_size')
+    max_page_size = getattr(settings, 'JSON_API_MAX_PAGE_SIZE', 100)
 
     def build_link(self, index):
         if not index:
@@ -55,8 +58,10 @@ class LimitOffsetPagination(LimitOffsetPagination):
     http://api.example.org/accounts/?page[limit]=100
     http://api.example.org/accounts/?page[offset]=400&page[limit]=100
     """
-    limit_query_param = 'page[limit]'
-    offset_query_param = 'page[offset]'
+    limit_query_param = getattr(settings, 'JSON_API_PAGE_LIMIT_PARAM', 'page[limit]')
+    offset_query_param = getattr(settings, 'JSON_API_PAGE_OFFSET_PARM','page[offset]')
+    # TODO: inconsistent w/max_page_size value default of 100
+    max_limit = getattr(settings, 'JSON_API_MAX_PAGE_LIMIT', None)
 
     def get_last_link(self):
         if self.count == 0:
@@ -96,3 +101,5 @@ def get_paginated_response(self, data):
                 ('prev', self.get_previous_link())
             ])
         })
+
+# TODO: Add CursorPagination

From ec7aaeac9a449af596c01368dbba35742882180f Mon Sep 17 00:00:00 2001
From: Alan Crosswell <alan@columbia.edu>
Date: Wed, 21 Mar 2018 19:18:07 -0400
Subject: [PATCH 2/6] isort, flake8

---
 example/tests/integration/test_sort.py | 11 +++++++++++
 rest_framework_json_api/exceptions.py  |  9 +++++++--
 rest_framework_json_api/mixins.py      | 14 +++++++++-----
 rest_framework_json_api/pagination.py  |  8 ++++----
 4 files changed, 31 insertions(+), 11 deletions(-)
 create mode 100644 example/tests/integration/test_sort.py

diff --git a/example/tests/integration/test_sort.py b/example/tests/integration/test_sort.py
new file mode 100644
index 00000000..617b9d24
--- /dev/null
+++ b/example/tests/integration/test_sort.py
@@ -0,0 +1,11 @@
+import pytest
+from django.urls import reverse
+
+pytestmark = pytest.mark.django_db
+
+# TODO: Need to have a view that includes the mixins.
+def test_sort_view(multiple_entries, client):
+    base_url = reverse('entry-list')
+    querystring = '?sort=-blog,headlinexx'
+    response = client.get(base_url + querystring)
+    assert response.status_code == 200
diff --git a/rest_framework_json_api/exceptions.py b/rest_framework_json_api/exceptions.py
index 69eebdb1..b85716a0 100644
--- a/rest_framework_json_api/exceptions.py
+++ b/rest_framework_json_api/exceptions.py
@@ -1,11 +1,14 @@
+import re
+
 from django.conf import settings
+from django.core.exceptions import FieldDoesNotExist, FieldError
 from django.utils.translation import ugettext_lazy as _
 from rest_framework import exceptions, status
-import re
 from rest_framework.response import Response
-from django.core.exceptions import FieldDoesNotExist, FieldError
+
 from rest_framework_json_api import utils
 
+
 def rendered_with_json_api(view):
     from rest_framework_json_api.renderers import JSONRenderer
     for renderer_class in getattr(view, 'renderer_classes', []):
@@ -13,6 +16,7 @@ def rendered_with_json_api(view):
             return True
     return False
 
+
 def unhandled_drf_exception_handler(exc, context):
     """
     Deals with exceptions that DRF doesn't catch, specifically for filter & sort query parameters:
@@ -54,6 +58,7 @@ def unhandled_drf_exception_handler(exc, context):
         ]
     return Response(errors, status=status_code)
 
+
 def exception_handler(exc, context):
     # Import this here to avoid potential edge-case circular imports, which
     # crashes with:
diff --git a/rest_framework_json_api/mixins.py b/rest_framework_json_api/mixins.py
index 7166bbe5..c198a753 100644
--- a/rest_framework_json_api/mixins.py
+++ b/rest_framework_json_api/mixins.py
@@ -27,8 +27,10 @@ class FilterMixin(object):
     A stackable Mixin that overrides get_queryset for JSON API filter query parameter support
     per http://jsonapi.org/recommendations/#filtering.
 
-    The `filter` syntax is `filter[name1]=list,of,alternative,values&filter[name2]=more,alternatives...`
-    which can be interpreted as `(name1 in [list,of,alternative,values]) and (name2 in [more,alternatives])`
+    The `filter` syntax is
+    `filter[name1]=list,of,alternative,values&filter[name2]=more,alternatives...`
+    which can be interpreted as `(name1 in [list,of,alternative,values])
+    and (name2 in [more,alternatives])`
     `name` can be `id` or attributes field.
 
     @example
@@ -44,7 +46,8 @@ def get_queryset(self):
         Override :meth:``get_queryset``
         """
         self.queryset = super(FilterMixin, self).get_queryset()
-        qp = dict(self.request.query_params if hasattr(self.request, 'query_params') else self.request.QUERY_PARAMS)
+        qp = dict(self.request.query_params if hasattr(self.request, 'query_params')
+                  else self.request.QUERY_PARAMS)
         if not qp:
             return self.queryset
         FILTER = 'filter['
@@ -53,7 +56,7 @@ def get_queryset(self):
         for k in qp:
             if k[:flen] == FILTER and k[-1] == ']':
                 attr = k[flen:-1]
-                filters[attr+"__in"] = qp.get(k)[0].split(',')
+                filters[attr + "__in"] = qp.get(k)[0].split(',')
 
         self.queryset = self.queryset.filter(**filters)
         return self.queryset
@@ -79,7 +82,8 @@ def get_queryset(self):
         Override :meth:``get_queryset``
         """
         self.queryset = super(SortMixin, self).get_queryset()
-        qp = dict(self.request.query_params if hasattr(self.request, 'query_params') else self.request.QUERY_PARAMS)
+        qp = dict(self.request.query_params if hasattr(self.request, 'query_params')
+                  else self.request.QUERY_PARAMS)
         if not qp:
             return self.queryset
         sorts = []
diff --git a/rest_framework_json_api/pagination.py b/rest_framework_json_api/pagination.py
index bc02cb05..6831658b 100644
--- a/rest_framework_json_api/pagination.py
+++ b/rest_framework_json_api/pagination.py
@@ -3,17 +3,17 @@
 """
 from collections import OrderedDict
 
+from django.conf import settings
 from rest_framework.pagination import LimitOffsetPagination, PageNumberPagination
 from rest_framework.utils.urls import remove_query_param, replace_query_param
 from rest_framework.views import Response
 
-from django.conf import settings
-
 
 class PageNumberPagination(PageNumberPagination):
     """
     A json-api compatible pagination format
-    TODO: Consider changing defaults to page[number] and page[size]. This would be a breaking change.
+    TODO: Consider changing defaults to page[number] and page[size].
+      This would be a breaking change.
     """
     page_query_param = getattr(settings, 'JSON_API_PAGE_NUMBER_PARAM', 'page')
     page_size_query_param = getattr(settings, 'JSON_API_PAGE_SIZE_PARAM', 'page_size')
@@ -59,7 +59,7 @@ class LimitOffsetPagination(LimitOffsetPagination):
     http://api.example.org/accounts/?page[offset]=400&page[limit]=100
     """
     limit_query_param = getattr(settings, 'JSON_API_PAGE_LIMIT_PARAM', 'page[limit]')
-    offset_query_param = getattr(settings, 'JSON_API_PAGE_OFFSET_PARM','page[offset]')
+    offset_query_param = getattr(settings, 'JSON_API_PAGE_OFFSET_PARM', 'page[offset]')
     # TODO: inconsistent w/max_page_size value default of 100
     max_limit = getattr(settings, 'JSON_API_MAX_PAGE_LIMIT', None)
 

From 0cf9877b678830c7e53f4962ee9b53450dba219f Mon Sep 17 00:00:00 2001
From: Alan Crosswell <alan@columbia.edu>
Date: Wed, 21 Mar 2018 19:24:28 -0400
Subject: [PATCH 3/6] no, really, all the flake8's

---
 example/tests/integration/test_sort.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/example/tests/integration/test_sort.py b/example/tests/integration/test_sort.py
index 617b9d24..d331e945 100644
--- a/example/tests/integration/test_sort.py
+++ b/example/tests/integration/test_sort.py
@@ -3,6 +3,7 @@
 
 pytestmark = pytest.mark.django_db
 
+
 # TODO: Need to have a view that includes the mixins.
 def test_sort_view(multiple_entries, client):
     base_url = reverse('entry-list')

From e69425fd7fbe5a845e6e63b7eaa6bf79db778ba9 Mon Sep 17 00:00:00 2001
From: Alan Crosswell <alan@columbia.edu>
Date: Thu, 22 Mar 2018 20:59:19 -0400
Subject: [PATCH 4/6] Add viewset Mixins to all the viewsets

---
 example/tests/integration/test_sort.py | 12 -----
 example/tests/test_views.py            | 70 ++++++++++++++++++++++++++
 example/views.py                       | 19 ++++---
 3 files changed, 82 insertions(+), 19 deletions(-)
 delete mode 100644 example/tests/integration/test_sort.py

diff --git a/example/tests/integration/test_sort.py b/example/tests/integration/test_sort.py
deleted file mode 100644
index d331e945..00000000
--- a/example/tests/integration/test_sort.py
+++ /dev/null
@@ -1,12 +0,0 @@
-import pytest
-from django.urls import reverse
-
-pytestmark = pytest.mark.django_db
-
-
-# TODO: Need to have a view that includes the mixins.
-def test_sort_view(multiple_entries, client):
-    base_url = reverse('entry-list')
-    querystring = '?sort=-blog,headlinexx'
-    response = client.get(base_url + querystring)
-    assert response.status_code == 200
diff --git a/example/tests/test_views.py b/example/tests/test_views.py
index db3a3407..204e7bbc 100644
--- a/example/tests/test_views.py
+++ b/example/tests/test_views.py
@@ -280,3 +280,73 @@ def test_no_content_response(self):
         response = self.client.delete(url)
         assert response.status_code == 204, response.rendered_content.decode()
         assert len(response.rendered_content) == 0, response.rendered_content.decode()
+
+
+class TestSortFilterViewSet(TestBase):
+    def setUp(self):
+        self.blog = Blog.objects.create(name='Some Blog', tagline="Also a blog")
+        self.entry1 = Entry.objects.create(blog=self.blog,
+                                           headline="common header",
+                                           body_text="1st body text")
+        self.entry2 = Entry.objects.create(blog=self.blog,
+                                           headline="differ header",
+                                           body_text="2nd body text")
+        self.entry3 = Entry.objects.create(blog=self.blog,
+                                           headline="common header",
+                                           body_text="3rd body text")
+
+    def test_sort_view(self):
+        url = '/entries'
+        querystring = 'sort=-headline,body_text'
+        response = self.client.get(url + '?page_size=10&' + querystring)
+        assert response.status_code == 200, response.content.decode()
+        j = json.loads(response.content)
+        assert len(j['data']) == 3
+        assert j['data'][0]['attributes']['headline'] == 'differ header'
+        assert j['data'][1]['attributes']['headline'] == 'common header'
+        assert j['data'][2]['attributes']['headline'] == 'common header'
+        assert j['data'][0]['attributes']['bodyText'] == '2nd body text'
+        assert j['data'][1]['attributes']['bodyText'] == '1st body text'
+        assert j['data'][2]['attributes']['bodyText'] == '3rd body text'
+
+    def test_filter_view(self):
+        url = '/entries'
+        querystring = 'filter[headline]=common header'
+        response = self.client.get(url + '?page_size=10&' + querystring)
+        assert response.status_code == 200, response.content.decode()
+        j = json.loads(response.content)
+        assert len(j['data']) == 2
+        assert j['data'][0]['attributes']['headline'] == 'common header'
+        assert j['data'][1]['attributes']['headline'] == 'common header'
+
+    def test_sort_filter_fields_view(self):
+        url = '/entries'
+        # TODO: this is a pre-existing bug in SparseFieldSetsMixin:
+        #  fields[body_text] vs. camelized bodyText in response.
+        querystring = 'sort=-headline,body_text&filter[headline]=common header'\
+                      '&fields[entries]=body_text,mod_date'
+        response = self.client.get(url + '?page_size=10&' + querystring)
+        assert response.status_code == 200, response.content.decode()
+        j = json.loads(response.content)
+        assert len(j['data']) == 2
+        assert j['data'][0]['attributes']['bodyText'] == '1st body text'
+        assert j['data'][1]['attributes']['bodyText'] == '3rd body text'
+        assert 'headline' not in j['data'][0]['attributes']
+
+    def test_sort_bad_key(self):
+        url = '/entries'
+        querystring = 'sort=-body_text,XxX'
+        response = self.client.get(url + '?page_size=10&' + querystring)
+        assert response.status_code == 400, response.content.decode()
+        j = json.loads(response.content)
+        assert j['errors'][0]['code'] == 'field_error'
+        assert j['errors'][0]['source']['parameter'] == 'XxX'
+
+    def test_filter_bad_key(self):
+        url = '/entries'
+        querystring = 'filter[XxX]=43'
+        response = self.client.get(url + '?page_size=10&' + querystring)
+        assert response.status_code == 400, response.content.decode()
+        j = json.loads(response.content)
+        assert j['errors'][0]['code'] == 'field_error'
+        assert j['errors'][0]['source']['parameter'] == 'XxX'
diff --git a/example/views.py b/example/views.py
index 6182c6df..eabe95c5 100644
--- a/example/views.py
+++ b/example/views.py
@@ -8,6 +8,7 @@
 from rest_framework_json_api.pagination import PageNumberPagination
 from rest_framework_json_api.utils import format_drf_errors
 from rest_framework_json_api.views import ModelViewSet, RelationshipView
+from rest_framework_json_api.mixins import MultipleIDMixin, FilterMixin, SortMixin
 
 from example.models import Author, Blog, Comment, Company, Entry, Project
 from example.serializers import (
@@ -22,12 +23,16 @@
 HTTP_422_UNPROCESSABLE_ENTITY = 422
 
 
-class BlogViewSet(ModelViewSet):
+class BaseModelViewSet(SortMixin, FilterMixin, MultipleIDMixin, ModelViewSet):
+    pass
+
+
+class BlogViewSet(BaseModelViewSet):
     queryset = Blog.objects.all()
     serializer_class = BlogSerializer
 
 
-class JsonApiViewSet(ModelViewSet):
+class JsonApiViewSet(BaseModelViewSet):
     """
     This is an example on how to configure DRF-jsonapi from
     within a class. It allows using DRF-jsonapi alongside
@@ -61,7 +66,7 @@ class BlogCustomViewSet(JsonApiViewSet):
     serializer_class = BlogSerializer
 
 
-class EntryViewSet(ModelViewSet):
+class EntryViewSet(BaseModelViewSet):
     queryset = Entry.objects.all()
     resource_name = 'posts'
 
@@ -77,12 +82,12 @@ class NonPaginatedEntryViewSet(EntryViewSet):
     pagination_class = NoPagination
 
 
-class AuthorViewSet(ModelViewSet):
+class AuthorViewSet(BaseModelViewSet):
     queryset = Author.objects.all()
     serializer_class = AuthorSerializer
 
 
-class CommentViewSet(ModelViewSet):
+class CommentViewSet(BaseModelViewSet):
     queryset = Comment.objects.all()
     serializer_class = CommentSerializer
     prefetch_for_includes = {
@@ -91,12 +96,12 @@ class CommentViewSet(ModelViewSet):
     }
 
 
-class CompanyViewset(ModelViewSet):
+class CompanyViewset(BaseModelViewSet):
     queryset = Company.objects.all()
     serializer_class = CompanySerializer
 
 
-class ProjectViewset(ModelViewSet):
+class ProjectViewset(BaseModelViewSet):
     queryset = Project.objects.all()
     serializer_class = ProjectSerializer
 

From 0469eb15bc9d090e51c61240e25340e859d6f6b7 Mon Sep 17 00:00:00 2001
From: Alan Crosswell <alan@columbia.edu>
Date: Thu, 22 Mar 2018 21:07:12 -0400
Subject: [PATCH 5/6] I missed an isort error

---
 example/views.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/example/views.py b/example/views.py
index eabe95c5..90d46a69 100644
--- a/example/views.py
+++ b/example/views.py
@@ -5,10 +5,10 @@
 import rest_framework_json_api.metadata
 import rest_framework_json_api.parsers
 import rest_framework_json_api.renderers
+from rest_framework_json_api.mixins import FilterMixin, MultipleIDMixin, SortMixin
 from rest_framework_json_api.pagination import PageNumberPagination
 from rest_framework_json_api.utils import format_drf_errors
 from rest_framework_json_api.views import ModelViewSet, RelationshipView
-from rest_framework_json_api.mixins import MultipleIDMixin, FilterMixin, SortMixin
 
 from example.models import Author, Blog, Comment, Company, Entry, Project
 from example.serializers import (

From 0c2675bbf43abb39fce3123ee8b406aa83da538b Mon Sep 17 00:00:00 2001
From: Alan Crosswell <alan@columbia.edu>
Date: Thu, 22 Mar 2018 21:15:57 -0400
Subject: [PATCH 6/6] python 3.4-3.5 vs. json.loads()

---
 example/tests/test_views.py | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/example/tests/test_views.py b/example/tests/test_views.py
index 204e7bbc..2be4516f 100644
--- a/example/tests/test_views.py
+++ b/example/tests/test_views.py
@@ -299,8 +299,8 @@ def test_sort_view(self):
         url = '/entries'
         querystring = 'sort=-headline,body_text'
         response = self.client.get(url + '?page_size=10&' + querystring)
-        assert response.status_code == 200, response.content.decode()
-        j = json.loads(response.content)
+        assert response.status_code == 200, response.content.decode('utf-8')
+        j = json.loads(response.content.decode('utf-8'))
         assert len(j['data']) == 3
         assert j['data'][0]['attributes']['headline'] == 'differ header'
         assert j['data'][1]['attributes']['headline'] == 'common header'
@@ -314,7 +314,7 @@ def test_filter_view(self):
         querystring = 'filter[headline]=common header'
         response = self.client.get(url + '?page_size=10&' + querystring)
         assert response.status_code == 200, response.content.decode()
-        j = json.loads(response.content)
+        j = json.loads(response.content.decode('utf-8'))
         assert len(j['data']) == 2
         assert j['data'][0]['attributes']['headline'] == 'common header'
         assert j['data'][1]['attributes']['headline'] == 'common header'
@@ -327,7 +327,7 @@ def test_sort_filter_fields_view(self):
                       '&fields[entries]=body_text,mod_date'
         response = self.client.get(url + '?page_size=10&' + querystring)
         assert response.status_code == 200, response.content.decode()
-        j = json.loads(response.content)
+        j = json.loads(response.content.decode('utf-8'))
         assert len(j['data']) == 2
         assert j['data'][0]['attributes']['bodyText'] == '1st body text'
         assert j['data'][1]['attributes']['bodyText'] == '3rd body text'
@@ -338,7 +338,7 @@ def test_sort_bad_key(self):
         querystring = 'sort=-body_text,XxX'
         response = self.client.get(url + '?page_size=10&' + querystring)
         assert response.status_code == 400, response.content.decode()
-        j = json.loads(response.content)
+        j = json.loads(response.content.decode('utf-8'))
         assert j['errors'][0]['code'] == 'field_error'
         assert j['errors'][0]['source']['parameter'] == 'XxX'
 
@@ -347,6 +347,6 @@ def test_filter_bad_key(self):
         querystring = 'filter[XxX]=43'
         response = self.client.get(url + '?page_size=10&' + querystring)
         assert response.status_code == 400, response.content.decode()
-        j = json.loads(response.content)
+        j = json.loads(response.content.decode('utf-8'))
         assert j['errors'][0]['code'] == 'field_error'
         assert j['errors'][0]['source']['parameter'] == 'XxX'