fixed backward compatibility;use columns.data field; release 1.19.0

Author: pigletto

CHANGES

@@ -1,3 +1,7 @@
+2019.10.02 - 1.19.0
+ - Fixed backward compatibility with version 1.16
+ - Use columns.data field (if defined in JavaScript) to determine columns definition
+
 2019.06.09 - 1.18.0
  - Added support for dict (.values) to rendering method (thanks Andreas Hasenkopf)
 

README.md

@@ -23,8 +23,8 @@ _django_datatables_view_ uses **GenericViews**, so your view should just inherit
 (there is also a DatatableMixin - pure datatables handler that can be used with the mixins of your choice, eg. django-braces). These are:
 
   * **model** - the model that should be used to populate the datatable
-  * **columns** - the columns that are going to be displayed. If not defined then django_datatables_view will look for 'name' in the columns definition provided in the request by DataTables, eg.: columnDefs: [{name: 'name', targets: [0]} (only works for datatables 1.10+)
-  * **order_columns** - list of column names used for sorting (eg. if user sorts by second column then second column name from this list will be used with order by clause). If not defined then django_datatables_view will look for 'name' in the columns definition provided in the request by DataTables, eg.: columnDefs: [{name: 'name', targets: [0]} (only works for datatables 1.10+)
+  * **columns** - the columns that are going to be displayed. If not defined then django_datatables_view will look for 'data' or 'name' in the columns definition provided in the request by DataTables, eg.: columns: [{data: 'first_name'}] (only works for datatables 1.10+)
+  * **order_columns** - list of column names used for sorting (eg. if user sorts by second column then second column name from this list will be used with order by clause). If not defined then django_datatables_view will look for 'data' or 'name' in the columns definition provided in the request by DataTables, eg.: columns: [{data: 'first_name'}] (only works for datatables 1.10+)
   * **filter_queryset** - if you want to filter your DataTable in some specific way then override this method. In case of older DataTables (pre 1.10) you need to override this method or there will be no filtering.
   * **filter_method** - returns 'istartswith' by default, you can override it to use different filtering method, e.g. icontains: return self.FILTER_ICONTAINS
 
@@ -173,18 +173,16 @@ This sample assumes that list of columns and order columns is defined on the cli
 $(document).ready(function() {
     var dt_table = $('.datatable').dataTable({
         order: [[ 0, "desc" ]],
-        columnDefs: [
+        columns: [
             {
-                name: 'name',
+                data: 'name',
                 orderable: true,
-                searchable: true,
-                targets: [0]
+                searchable: true
             },
             {
-                name: 'description',
+                data: 'description',
                 orderable: true,
                 searchable: true,
-                targets: [1]
             }
         ],
         searching: true,

django_datatables_view/base_datatable_view.py

@@ -21,6 +21,9 @@ class DatatableMixin(object):
     none_string = ''
     escape_values = True  # if set to true then values returned by render_column will be escaped
     columns_data = []
+    is_data_list = True  # determines the type of results. If JavaScript passes data attribute that is not an integer
+                         # then it expects dictionary with specific fields in
+                         # the response, see: https://datatables.net/reference/option/columns.data
 
     FILTER_ISTARTSWITH = 'istartswith'
     FILTER_ICONTAINS = 'icontains'
@@ -48,16 +51,16 @@ def get_order_columns(self):
             By default returns self.order_columns but if these are not defined it tries to get columns
             from the request using the columns[i][name] attribute. This requires proper client side definition of
             columns, eg:
-                columnDefs: [
+                columns: [
                     {
                         name: 'username',
+                        data: 'username',
                         orderable: true,
-                        targets: [0]
                     },
                     {
                         name: 'email',
-                        orderable: false,
-                        targets: [1]
+                        data: 'email',
+                        orderable: false
                     }
                 ]
         """
@@ -67,9 +70,14 @@ def get_order_columns(self):
         # try to build list of order_columns using request data
         order_columns = []
         for column_def in self.columns_data:
-            if column_def['name']:
+            if column_def['name'] or not self.is_data_list:
+                # if self.is_data_list is False then we have a column name in the 'data' attribute, otherwise
+                # 'data' attribute is an integer with column index
                 if column_def['orderable']:
-                    order_columns.append(column_def['name'])
+                    if self.is_data_list:
+                        order_columns.append(column_def['name'])
+                    else:
+                        order_columns.append(column_def.get('data'))
                 else:
                     order_columns.append('')
             else:
@@ -83,17 +91,16 @@ def get_order_columns(self):
     def get_columns(self):
         """ Returns the list of columns to be returned in the result set.
             By default returns self.columns but if these are not defined it tries to get columns
-            from the request using the columns[i][name] attribute. This requires proper client side definition of
+            from the request using the columns[i][data] or columns[i][name] attribute.
+            This requires proper client side definition of
             columns, eg:
 
-                columnDefs: [
+                columns: [
                     {
-                        name: 'username',
-                        targets: [0]
+                        data: 'username'
                     },
                     {
-                        name: 'email',
-                        targets: [1]
+                        data: 'email'
                     }
                 ]
         """
@@ -102,10 +109,17 @@ def get_columns(self):
 
         columns = []
         for column_def in self.columns_data:
-            if column_def['name']:
-                columns.append(column_def['name'])
+            if self.is_data_list:
+                # if self.is_data_list is true then 'data' atribute is an integer - column index, so we
+                # cannot use it as a column name, let's try 'name' attribute instead
+                col_name = column_def['name']
+            else:
+                col_name = column_def['data']
+
+            if col_name:
+                columns.append(col_name)
             else:
-                raise Exception('self.columns is not defined and there is no \'name\' defined in columns definition!')
+                return self.columns
 
         return columns
 
@@ -252,21 +266,37 @@ def filter_queryset(self, qs):
             q = Q()
             filter_method = self.get_filter_method()
             for col_no, col in enumerate(self.columns_data):
+                # col['data'] - https://datatables.net/reference/option/columns.data
+                data_field = col['data']
+                try:
+                    data_field = int(data_field)
+                except ValueError:
+                    pass
+                if isinstance(data_field, int):
+                    column = columns[data_field]  # by index so we need columns definition in self._columns
+                else:
+                    column = data_field
+                column = column.replace('.', '__')
                 # apply global search to all searchable columns
                 if search and col['searchable']:
-                    q |= Q(**{'{0}__{1}'.format(columns[col_no].replace('.', '__'), filter_method): search})
+                    q |= Q(**{'{0}__{1}'.format(column, filter_method): search})
 
                 # column specific filter
                 if col['search.value']:
                     qs = qs.filter(**{
-                        '{0}__{1}'.format(columns[col_no].replace('.', '__'), filter_method): col['search.value']})
+                        '{0}__{1}'.format(column, filter_method): col['search.value']})
             qs = qs.filter(q)
         return qs
 
     def prepare_results(self, qs):
         data = []
         for item in qs:
-            data.append([self.render_column(item, column) for column in self._columns])
+            if self.is_data_list:
+                data.append([self.render_column(item, column) for column in self._columns])
+            else:
+                row = {col_data['data']: self.render_column(item, col_data['data']) for col_data in self.columns_data}
+                data.append(row)
+
         return data
 
     def handle_exception(self, e):
@@ -280,6 +310,20 @@ def get_context_data(self, *args, **kwargs):
             # prepare columns data (for DataTables 1.10+)
             self.columns_data = self.extract_datatables_column_data()
 
+            # determine the response type based on the 'data' field passed from JavaScript
+            # https://datatables.net/reference/option/columns.data
+            # col['data'] can be an integer (return list) or string (return dictionary)
+            # we only check for the first column definition here as there is no way to return list and dictionary
+            # at once
+            self.is_data_list = True
+            if self.columns_data:
+                self.is_data_list = False
+                try:
+                    int(self.columns_data[0]['data'])
+                    self.is_data_list = True
+                except ValueError:
+                    pass
+
             # prepare list of columns to be returned
             self._columns = self.get_columns()
 

setup.py

@@ -1,7 +1,7 @@
 from setuptools import setup, find_packages
 import os
 
-version = '1.18.0'
+version = '1.19.0'
 
 base_dir = os.path.dirname(__file__)