Initial work for the datatables_listview, this is far away to be functional, just commit to do PC switch and take a bath.

Author: MiltonLn

.gitignore

@@ -87,3 +87,6 @@ ENV/
 
 # Rope project settings
 .ropeproject
+
+# Pycharm
+.idea/

datatables_listview/core/__init__.py

@@ -0,0 +1,40 @@
+from django.db.models import Q
+
+
+def generate_q_objects_by_fields_and_words(fields, search_text):
+    """
+    Author: Milton Lenis
+    Date: 16 April 2017
+    A handy method to generate Q Objects for filtering the queryset, this generates a Q Object by each field with each
+    word, that means, if you have a search_term with 3 words and 3 fields this generates 9 Q Objects.
+
+    This also looks if the field has choices, if so, it cast to the choices internal representation to do the Q Object
+    creation correctly
+
+    Because Q Objects internally are subclasses of django.utils.tree.Node we can 'add' Q Objects with connectors,
+    see: https://bradmontgomery.net/blog/adding-q-objects-in-django/
+    """
+    q = Q()
+    search_text = search_text.split(" ")
+    for field in fields:
+        for word in search_text:
+            if field.choices:
+                # Build a dict with the dictionary to do search by choices display
+                field_choices = {key.lower(): value for key, value in field.choices}
+                # Search if the searched word exists in the field choices
+                display_to_value = field_choices.get(word.lower(), "")
+                if display_to_value:
+                    search_criteria = {field.name: display_to_value}
+                    q.add(
+                        Q(**search_criteria),
+                        Q.OR
+                    )
+            else:
+                instruction = "%s__icontains" % field.name
+                search_criteria = {instruction: word}
+                # Adding q objects with OR connector
+                q.add(
+                    Q(**search_criteria),
+                    Q.OR
+                )
+    return q

datatables_listview/core/utils.py

@@ -0,0 +1,140 @@
+from collections import namedtuple
+
+from django.core.exceptions import ImproperlyConfigured
+from django.http import JsonResponse
+
+from .utils import generate_q_objects_by_fields_and_words
+
+
+class DatatablesListView:
+    """
+    Author: Milton Lenis
+    Date: 16 April 2017
+    View implementation for datatables_listview
+    """
+    model = None
+    queryset = None
+    fields = None
+
+    def get_queryset(self):
+        """
+        Author: Milton Lenis
+        Date: 16 April 2017
+        Method to get the queryset or generate one with the model
+        """
+        if self.queryset is None:
+            if self.model:
+                return self.model._default_manager.all()
+            else:
+                raise ImproperlyConfigured(
+                    "%(cls)s is missing a QuerySet. Define "
+                    "%(cls)s.model, %(cls)s.queryset, or override "
+                    "%(cls)s.get_queryset()." % {
+                        'cls': self.__class__.__name__
+                    }
+                )
+        return self.queryset.all()
+
+    def get_field_names(self):
+        """
+        Author: Milton Lenis
+        Date: 16 April 2017
+        Method to get the fields definition for this listview, return all of the model fields if the developer doesn't
+        setup the fields
+        """
+        if self.fields is None:
+            return [field.name for field in self.model._meta.get_field_names()]
+        else:
+            return self.fields
+
+    def get_field_instances(self):
+        """
+        Author: Milton Lenis
+        Date: 16 April 2017
+        Method to get all the field instances using the Django's Model _meta API
+        """
+        field_names = self.get_field_names()
+        return [self.model._meta.get_field(field_name) for field_name in field_names]
+
+    def get_draw_parameters(self, request):
+        """
+        Author: Milton Lenis
+        Date: 16 April 2017
+        Method to extracting the draw parameters from the request, those parameters are sent by datatables server-side
+        """
+        # Using namedtuple for readability, the var name is capitalized because this namedtuple is used like a class
+        Draw = namedtuple('Draw', ['start', 'end', 'sort_column', 'sort_order', 'search', 'draw'])
+
+        start = int(request.GET.get('start', 0))
+        end = start + int(request.GET.get('length', 0))
+        sort_column = self.get_field_names()[int(request.GET.get('order[0][column]', 0))]
+        sort_order = request.GET.get('order[0][dir]', "")
+        search = request.GET.get('search[value]', "")
+        draw = int(request.GET.get('draw', 0))
+
+        return Draw(start, end, sort_column, sort_order, search, draw)
+
+    def filter_by_search_text(self, queryset, search_text):
+        """
+        Author: Milton Lenis
+        Date: 16 April 2017
+        Method to filter the queryset given a search_text, this filters the queryset by each one of the fields doing
+        icontains lookup and spliting the search_text into words
+        """
+        # First we need to generate Q objects to do the filtering all over the queryset
+        q_objects_for_filtering = generate_q_objects_by_fields_and_words(self.get_field_instances(), search_text)
+        return queryset.filter(q_objects_for_filtering)
+
+    def filter_by_draw_parameters(self, queryset, draw_parameters):
+        """
+        Author: Milton Lenis
+        Date: 16 April 2017
+        Method ot filter the queryset with the draw parameters, this returns the queryset sorted (Depending of the
+        order) by a column and slices the queryset by a start position and end position
+        """
+        sort_order = ""
+        if draw_parameters.sort_order == "desc":
+            sort_order = "-"
+        sort_criteria = "{0}{1}".format(sort_order, draw_parameters.sort_column)
+        return queryset.order_by(sort_criteria)[draw_parameters.start:draw_parameters.end]
+
+    def generate_data(self, request):
+        """
+        Author: Milton Lenis
+        Date: 16 April 2017
+        Method to generate the final data required for the JsonResponse, it returns a dictionary with the data
+        formated as datatables requires it
+        """
+        draw_parameters = self.get_draw_parameters(request)
+        queryset = self.get_queryset()
+
+        if draw_parameters.search:
+            queryset = self.filter_by_search_text(queryset, draw_parameters.search)
+
+        objects_count = queryset.count()
+        # This uses the 'filter_by_draw_params' to filter the queryset according with the draw parameters
+        # This means: it's the filter for the displaying page of the datatable
+        queryset = self.filter_by_draw_parameters(queryset, draw_parameters)
+        if self.get_options_list():
+            generated_rows = self.generate_rows_with_options()
+        else:
+            generated_rows = self.generate_rows()
+        return {
+            'draw': draw_parameters.draw,
+            'recordsTotal': objects_count,
+            'recodsFiltered': objects_count,
+            'data': generated_rows
+        }
+
+    def get(self, request, *args, **kwargs):
+        """
+        Author: Milton Lenis
+        Date: April 16 2017
+        If the request is ajax it returns the requested data as a JSON, if not, it calls the super to give a normal
+        http response and show the template
+        """
+        if request.is_ajax():
+            final_data = self.generate_data(request)
+            return JsonResponse(final_data)
+        else:
+            return super(DatatablesListView, self).get(request, *args, **kwargs)

datatables_listview/core/views.py

@@ -0,0 +1,115 @@
+//
+// Pipelining function for DataTables. To be used to the `ajax` option of DataTables
+//
+$.fn.dataTable.pipeline = function ( opts ) {
+    // Configuration options
+    var conf = $.extend( {
+        pages: 5,     // number of pages to cache
+        url: '',      // script url
+        data: null,   // function or object with parameters to send to the server
+                      // matching how `ajax.data` works in DataTables
+        method: 'GET' // Ajax HTTP method
+    }, opts );
+
+    // Private variables for storing the cache
+    var cacheLower = -1;
+    var cacheUpper = null;
+    var cacheLastRequest = null;
+    var cacheLastJson = null;
+
+    return function ( request, drawCallback, settings ) {
+        var ajax          = false;
+        var requestStart  = request.start;
+        var drawStart     = request.start;
+        var requestLength = request.length;
+        var requestEnd    = requestStart + requestLength;
+
+        if ( settings.clearCache ) {
+            // API requested that the cache be cleared
+            ajax = true;
+            settings.clearCache = false;
+        }
+        else if ( cacheLower < 0 || requestStart < cacheLower || requestEnd > cacheUpper ) {
+            // outside cached data - need to make a request
+            ajax = true;
+        }
+        else if ( JSON.stringify( request.order )   !== JSON.stringify( cacheLastRequest.order ) ||
+                  JSON.stringify( request.columns ) !== JSON.stringify( cacheLastRequest.columns ) ||
+                  JSON.stringify( request.search )  !== JSON.stringify( cacheLastRequest.search )
+        ) {
+            // properties changed (ordering, columns, searching)
+            ajax = true;
+        }
+
+        // Store the request for checking next time around
+        cacheLastRequest = $.extend( true, {}, request );
+
+        if ( ajax ) {
+            // Need data from the server
+            if ( requestStart < cacheLower ) {
+                requestStart = requestStart - (requestLength*(conf.pages-1));
+
+                if ( requestStart < 0 ) {
+                    requestStart = 0;
+                }
+            }
+
+            cacheLower = requestStart;
+            cacheUpper = requestStart + (requestLength * conf.pages);
+
+            request.start = requestStart;
+            request.length = requestLength*conf.pages;
+
+            // Provide the same `data` options as DataTables.
+            if ( $.isFunction ( conf.data ) ) {
+                // As a function it is executed with the data object as an arg
+                // for manipulation. If an object is returned, it is used as the
+                // data object to submit
+                var d = conf.data( request );
+                if ( d ) {
+                    $.extend( request, d );
+                }
+            }
+            else if ( $.isPlainObject( conf.data ) ) {
+                // As an object, the data given extends the default
+                $.extend( request, conf.data );
+            }
+
+            settings.jqXHR = $.ajax( {
+                "type":     conf.method,
+                "url":      conf.url,
+                "data":     request,
+                "dataType": "json",
+                "cache":    false,
+                "success":  function ( json ) {
+                    cacheLastJson = $.extend(true, {}, json);
+
+                    if ( cacheLower != drawStart ) {
+                        json.data.splice( 0, drawStart-cacheLower );
+                    }
+                    if ( requestLength >= -1 ) {
+                        json.data.splice( requestLength, json.data.length );
+                    }
+
+                    drawCallback( json );
+                }
+            } );
+        }
+        else {
+            json = $.extend( true, {}, cacheLastJson );
+            json.draw = request.draw; // Update the echo for each response
+            json.data.splice( 0, requestStart-cacheLower );
+            json.data.splice( requestLength, json.data.length );
+
+            drawCallback(json);
+        }
+    }
+};
+
+// Register an API method that will empty the pipelined data, forcing an Ajax
+// fetch on the next draw (i.e. `table.clearPipeline().draw()`)
+$.fn.dataTable.Api.register( 'clearPipeline()', function () {
+    return this.iterator( 'table', function ( settings ) {
+        settings.clearCache = true;
+    } );
+} );

datatables_listview/static/datatables_listview/js/datatables_pipeline.js

@@ -0,0 +1,89 @@
+$(document).ready(function () {
+
+    // Buttons definition for the datatable
+    try{
+        var custom_buttons = custom_buttons;
+    }catch(err){
+        var custom_buttons = null;
+    }
+    var final_buttons;
+    if(custom_buttons){
+        final_buttons = custom_buttons;
+    }else{
+        final_buttons = [
+            {
+                extend: 'copy',
+                exportOptions: {
+                    columns: ':not(:last)'
+                },
+                text: 'Copy'
+            },
+            {
+                extend: 'csv',
+                exportOptions: {
+                    columns: ':not(:last)'
+                },
+                text: 'CSV'
+            },
+            {
+                extend: 'excel',
+                exportOptions: {
+                    columns: ':not(:last)'
+                },
+                text: 'Excel'
+            },
+            {
+                extend: 'pdf',
+                exportOptions: {
+                    columns: ':not(:last)'
+                },
+                text: 'PDF'
+            },
+
+            {
+                extend: 'print',
+                customize: function (win) {
+                    $(win.document.body).addClass('white-bg');
+                    $(win.document.body).css('font-size', '10px');
+
+                    $(win.document.body).find('table')
+                        .addClass('compact')
+                        .css('font-size', 'inherit');
+                },
+                exportOptions: {
+                    columns: ':not(:last)'
+                },
+                text: 'Imprimir'
+            }
+        ]
+    }
+    // =========================================================================================================
+
+    // Columns definition
+    var columns = column_defs;
+
+    if(opciones){
+        columns.push({"title": "Options", "targets": columns.length, "orderable": false, "searchable":false});
+    }
+
+    //==========================================================================================================
+
+    $("#datatable-rady").DataTable({
+        dom: '<"html5buttons"B>lTfgitp',
+        language: {
+            "url": "//cdn.datatables.net/plug-ins/1.10.11/i18n/Spanish.json"
+        },
+        responsive: true,
+        bAutoWidth: false,
+        pageLength: 10,
+        columnDefs: columns,
+        serverSide: true,
+        processing: true,
+        ajax: $.fn.dataTable.pipeline({
+            url: "",
+            pages: 5 // number of pages to cache
+        }),
+        buttons: final_buttons
+
+    });
+});