Merge branch 'named-filter-forms'

Conflicts:
	flask_admin/model/base.py

flask_admin/model/base.py

+import re
 import warnings
 
 from flask import request, url_for, redirect, flash, abort, json, Response
@@ -18,6 +19,25 @@ from .helpers import prettify_name, get_mdict_item_or_list
 from .ajax import AjaxModelLoader
 
 
+try:
+    from collections import OrderedDict
+except ImportError:
+    # Bare-bones OrderedDict implementation for Python2.6 compatibility
+    class OrderedDict(dict):
+        def __init__(self, *args, **kwargs):
+            dict.__init__(self, *args, **kwargs)
+            self.ordered_keys = []
+        def __setitem__(self, key, value):
+            self.ordered_keys.append(key)
+            dict.__setitem__(self, key, value)
+        def __iter__(self):
+            return (k for k in self.ordered_keys)
+        def iteritems(self):
+            return ((k, self[k]) for k in self.ordered_keys)
+        def items(self):
+            return list(self.iteritems())
+
+
 class BaseModelView(BaseView, ActionsMixin):
     """
         Base model view.
@@ -252,6 +272,18 @@ class BaseModelView(BaseView, ActionsMixin):
                 column_filters = ('user', 'email')
     """
     
+    named_filter_urls = False
+    """
+        Set to True to use human-readable names for filters in URL parameters.
+        
+        False by default so as to be robust across translations.
+        
+        Changing this parameter will break any existing URLs.
+        
+        Override unique_filter_label() if you want to change the default format
+        of filter urls. This parameter only controls the default method.
+    """
+
     column_display_pk = ObsoleteAttr('column_display_pk',
                                      'list_display_pk',
                                      False)
@@ -544,25 +576,19 @@ class BaseModelView(BaseView, ActionsMixin):
             self.column_descriptions = dict()
 
         if self._filters:
-            self._filter_groups = []
-            self._filter_dict = dict()
-
-            for i, n in enumerate(self._filters):
-                if n.name not in self._filter_dict:
-                    group = []
-                    self._filter_dict[n.name] = group
-                    self._filter_groups.append((n.name, group))
-                else:
-                    group = self._filter_dict[n.name]
-
-                group.append((i, n.operation()))
-
-            self._filter_types = dict((i, f.data_type)
-                                      for i, f in enumerate(self._filters)
-                                      if f.data_type)
+            self._flattened_filters_by_group = OrderedDict()
+
+            for flt in self._filters:
+                if flt.name not in self._flattened_filters_by_group:
+                    self._flattened_filters_by_group[flt.name] = []
+                group = self._flattened_filters_by_group[flt.name]
+                group.append({'name': flt.name,
+                              'label': self.unique_filter_label(flt),
+                              'operation': flt.operation(),
+                              'options': flt.get_options(self) or None,
+                              'data_type': flt.data_type})
         else:
-            self._filter_groups = None
-            self._filter_types = None
+            self._flattened_filters_by_group = None
 
         # Form rendering rules
         if self.form_create_rules:
@@ -948,45 +974,82 @@ class BaseModelView(BaseView, ActionsMixin):
     def get_empty_list_message(self):
         return gettext('There are no items in the table.')
 
-    # URL generation helper
-    def _get_extra_args(self):
+    def unique_filter_label(self, flt):
         """
-            Return arguments from query string.
+            Given a filter `flt`, return a unique name for that filter in
+            this view.
+            
+            By default, returns a numeric index or a human-readable filter name
+            
+            Does not include the `flt[n]_` portion of the filter name.
+            
+            To use custom names, override this function, eg
+            def unique_filter_label(self, flt):
+                return flt.name + flt.__class__.__name__
+                
+            Be aware that if you override this method, the default URL format
+            will no longer work.
         """
-        page = request.args.get('page', 0, type=int)
-        sort = request.args.get('sort', None, type=int)
-        sort_desc = request.args.get('desc', None, type=int)
-        search = request.args.get('search', None)
+        if self.named_filter_urls:
+            return re.sub('\W', '_', u'{name}_{operation}'.format(name=flt.name, operation=flt.operation())).lower()
+        else:
+            return str(self._filters.index(flt))
+
+    def get_filter_args(self):
+        """
+            Retrieve and parse filter parameters from the request URL.
+            
+            Returns a list of 2-tuples in the format [(idx, value), ...],
+            where idx is the index into the list returned by get_filters().
+            
+            Override this method to provide your own URL filter format.
+        """
+        if not self._filters:
+            return None
+
+        filter_idx_by_label = dict((self.unique_filter_label(flt), i) for i, flt in enumerate(self._filters))
         
-        # Gather filters
-        if self._filters:
         sfilters = []
 
         for n in request.args:
-                if n.startswith('flt'):
-                    ofs = n.find('_')
-                    if ofs == -1:
+            if not n.startswith('flt'):
+                continue
+            if '_' not in n:
                 continue
 
+            pos, filter_label = n[3:].split('_', 1)
+            
+            # If pos not specified, just add incrementally to the list.
+            pos = int(pos) if pos else len(sfilters)
+
             try:
-                        pos = int(n[3:ofs])
-                        idx = int(n[ofs + 1:])
+                # See if filter is numeric
+                idx = int(filter_label)
             except ValueError:
+                # If non-numeric, look filter up by name
+                try:
+                    idx = filter_idx_by_label[filter_label]
+                except KeyError:
+                    # No matching filter name
                     continue
 
-                    if idx >= 0 and idx < len(self._filters):
+            if 0 <= idx < len(self._filters):
                 flt = self._filters[idx]
-
                 value = request.args[n]
-
                 if flt.validate(value):
                     sfilters.append((pos, (idx, flt.clean(value))))
 
-            filters = [v[1] for v in sorted(sfilters, key=lambda n: n[0])]
-        else:
-            filters = None
+        return [v[1] for v in sorted(sfilters, key=lambda n: n[0])]
 
-        return page, sort, sort_desc, search, filters
+    def _get_listing_args(self):
+        """
+            Return generic list view arguments from query string.
+        """
+        page = request.args.get('page', 0, type=int)
+        sort = request.args.get('sort', None, type=int)
+        sort_desc = request.args.get('desc', None, type=int)
+        search = request.args.get('search', None)
+        return page, sort, sort_desc, search
 
     def _get_url(self, view=None, page=None, sort=None, sort_desc=None,
                  search=None, filters=None):
@@ -1016,8 +1079,8 @@ class BaseModelView(BaseView, ActionsMixin):
         kwargs = dict(page=page, sort=sort, desc=sort_desc, search=search)
 
         if filters:
-            for i, flt in enumerate(filters):
-                key = 'flt%d_%d' % (i, flt[0])
+            for flt in filters:
+                key = 'flt_%s' % self.unique_filter_label(self._filters[flt[0]])
                 kwargs[key] = flt[1]
 
         return url_for(view, **kwargs)
@@ -1038,11 +1101,11 @@ class BaseModelView(BaseView, ActionsMixin):
         """
         return rec_getattr(model, name)
 
-    def _get_filter_dict(self):
+    def filters_by_label(self):
         """
-            Return flattened filter dictionary which can be JSON-serialized.
+            Flattened dict of all filters, indexed by their label.
         """
-        return dict((as_unicode(k), v) for k, v in iteritems(self._filter_dict))
+        return dict((self.unique_filter_label(flt), flt) for flt in self._filters)
 
     @contextfunction
     def get_list_value(self, context, model, name):
@@ -1104,7 +1167,8 @@ class BaseModelView(BaseView, ActionsMixin):
             List view
         """
         # Grab parameters from URL
-        page, sort_idx, sort_desc, search, filters = self._get_extra_args()
+        page, sort_idx, sort_desc, search = self._get_listing_args()
+        filters = self.get_filter_args()
 
         # Map column index to column name
         sort_column = self._get_column_by_idx(sort_idx)
@@ -1120,18 +1184,6 @@ class BaseModelView(BaseView, ActionsMixin):
         if count % self.page_size != 0:
             num_pages += 1
 
-        # Pregenerate filters
-        if self._filters:
-            filters_data = dict()
-
-            for idx, f in enumerate(self._filters):
-                flt_data = f.get_options(self)
-
-                if flt_data:
-                    filters_data[idx] = flt_data
-        else:
-            filters_data = None
-
         # Various URL generation helpers
         def pager_url(p):
             # Do not add page number if it is first page
@@ -1186,9 +1238,7 @@ class BaseModelView(BaseView, ActionsMixin):
                                search=search,
                                # Filters
                                filters=self._filters,
-                               filter_groups=self._filter_groups,
-                               filter_types=self._filter_types,
-                               filter_data=filters_data,
+                               filter_groups=self._flattened_filters_by_group,
                                active_filters=filters,
 
                                # Actions

flask_admin/static/admin/js/filters.js

-var AdminFilters = function(element, filters_element, operations, options, types) {
+var AdminFilters = function(element, filters_element, filters_by_group) {
     var $root = $(element);
     var $container = $('.filters', $root);
     var lastCount = 0;
@@ -23,7 +23,7 @@ var AdminFilters = function(element, filters_element, operations, options, types
         return false;
     }
 
-    function addFilter(name, op) {
+    function addFilter(name, subfilters) {
         var $el = $('<tr />').appendTo($container);
 
         // Filter list
@@ -41,8 +41,8 @@ var AdminFilters = function(element, filters_element, operations, options, types
         var $select = $('<select class="filter-op" />')
                       .change(changeOperation);
 
-        $(op).each(function() {
-            $select.append($('<option/>').attr('value', this[0]).text(this[1]));
+        $(subfilters).each(function() {
+            $select.append($('<option/>').attr('value', this.label).text(this.operation));
         });
 
         $el.append(
@@ -51,16 +51,14 @@ var AdminFilters = function(element, filters_element, operations, options, types
 
         $select.select2({width: 'resolve'});
 
-        // Input
-        var optId = op[0][0];
-
         var $field;
 
-        if (optId in options) {
+        var firstFilter = subfilters[0];
+        if (firstFilter.options) {
             $field = $('<select class="filter-val" />')
-                        .attr('name', 'flt' + lastCount + '_' + optId);
+                        .attr('name', 'flt' + lastCount + '_' + firstFilter.label);
 
-            $(options[optId]).each(function() {
+            $(firstFilter.options).each(function() {
                 $field.append($('<option/>')
                     .val(this[0]).text(this[1]));
             });
@@ -70,13 +68,13 @@ var AdminFilters = function(element, filters_element, operations, options, types
         } else
         {
             $field = $('<input type="text" class="filter-val" />')
-                        .attr('name', 'flt' + lastCount + '_' + optId);
+                        .attr('name', 'flt' + lastCount + '_' + firstFilter.label);
             $el.append($('<td/>').append($field));
         }
 
-        if (optId in types) {
-            $field.attr('data-role', types[optId]);
-            faForm.applyStyle($field, types[optId]);
+        if (firstFilter.data_type) {
+            $field.attr('data-role', firstFilter.data_type);
+            faForm.applyStyle($field, firstFilter.data_type);
         }
 
         lastCount += 1;
@@ -84,8 +82,7 @@ var AdminFilters = function(element, filters_element, operations, options, types
 
     $('a.filter', filters_element).click(function() {
         var name = $(this).text().trim();
-
-        addFilter(name, operations[name]);
+        addFilter(name, filters_by_group[name]);
 
         $('button', $root).show();
 

flask_admin/templates/admin/model/layout.html

@@ -5,7 +5,7 @@
     <ul class="dropdown-menu field-filters">
         {% for k in filter_groups %}
         <li>
-            <a href="javascript:void(0)" class="filter" onclick="return false;">{{ k[0] }}</a>
+            <a href="javascript:void(0)" class="filter" onclick="return false;">{{ k }}</a>
         </li>
         {% endfor %}
     </ul>
@@ -23,29 +23,29 @@
         <table class="filters">
             {%- for i, flt in enumerate(active_filters) -%}
             <tr>
-                {% set filter = admin_view._filters[flt[0]] %}
+                {% set filter = filters[flt[0]] %}
+                {%- set filter_label = admin_view.unique_filter_label(filter) -%}
                 <td>
                     <a href="javascript:void(0)" class="btn remove-filter" title="{{ _gettext('Remove Filter') }}">
-                        <span class="close-icon">&times;</span>&nbsp;{{ filters[flt[0]] }}
+                        <span class="close-icon">&times;</span>&nbsp;{{ filter.name }}
                     </a>
                 </td>
                 <td>
                     <select class="filter-op" data-role="select2">
-                        {% for op in admin_view._filter_dict[filter.name] %}
-                        <option value="{{ op[0] }}"{% if flt[0] == op[0] %} selected="selected"{% endif %}>{{ op[1] }}</option>
+                        {% for subfilter in filter_groups[filter.name] %}
+                        <option value="{{ subfilter.label }}"{% if subfilter.label == filter_label %} selected="selected"{% endif %}>{{ subfilter.operation }}</option>
                         {% endfor %}
                     </select>
                 </td>
                 <td>
-                    {%- set data = filter_data.get(flt[0]) -%}
-                    {%- if data -%}
-                    <select name="flt{{ i }}_{{ flt[0] }}" class="filter-val" data-role="select2">
-                        {%- for d in data %}
-                        <option value="{{ d[0] }}"{% if flt[1] == d[0] %} selected{% endif %}>{{ d[1] }}</option>
+                    {%- if filter.options -%}
+                    <select name="flt{{ i }}_{{ filter_label }}" class="filter-val" data-role="select2">
+                        {%- for o in filter.options %}
+                        <option value="{{ o[0] }}"{% if flt[1] == o[0] %} selected{% endif %}>{{ o[1] }}</option>
                         {%- endfor %}
                     </select>
                     {%- else -%}
-                        <input name="flt{{ i }}_{{ flt[0] }}" type="text" value="{{ flt[1] or '' }}" class="filter-val"{% if flt[0] in filter_types %} data-role="{{ filter_types[flt[0]] }}"{% endif %}></input>
+                        <input name="flt{{ i }}_{{ filter_label }}" type="text" value="{{ flt[1] or '' }}" class="filter-val"{% if filter.data_type %} data-role="{{ filter.data_type }}"{% endif %}></input>
                     {%- endif -%}
                 </td>
             </tr>

flask_admin/templates/admin/model/list.html

@@ -157,12 +157,10 @@
                 html: true,
                 placement: 'bottom'
             });
-            {% if filter_groups is not none and filter_data is not none %}
+            {% if filter_groups is not none %}
                 var filter = new AdminFilters(
                     '#filter_form', '.field-filters',
-                    {{ admin_view._get_filter_dict()|tojson|safe }},
-                    {{ filter_data|tojson|safe }},
-                    {{ filter_types|tojson|safe }}
+                    {{ filter_groups|tojson|safe }}
                 );
             {% endif %}
         })(jQuery);

flask_admin/tests/sqlamodel/test_basic.py

@@ -233,61 +233,52 @@ def test_column_filters():
 
     eq_(len(view._filters), 4)
 
-    eq_(view._filter_dict, {
-        u'Test1': [
-            (0, u'equals'),
-            (1, u'not equal'),
-            (2, u'contains'),
-            (3, u'not contains')
-        ]})
+    eq_([ (f['label'], f['operation']) for f in view._flattened_filters_by_group['Test1'] ],
+        [('0', u'equals'),
+         ('1', u'not equal'),
+         ('2', u'contains'),
+         ('3', u'not contains')])
 
     # Test filter that references property
     view = CustomModelView(Model2, db.session,
                            column_filters=['model1'])
 
-    eq_(view._filter_dict, {
-        u'Model1 / Test1': [
-            (0, u'equals'),
-            (1, u'not equal'),
-            (2, u'contains'),
-            (3, u'not contains')
-        ],
-        'Model1 / Test2': [
-            (4, 'equals'),
-            (5, 'not equal'),
-            (6, 'contains'),
-            (7, 'not contains')
-        ],
-        u'Model1 / Test3': [
-            (8, u'equals'),
-            (9, u'not equal'),
-            (10, u'contains'),
-            (11, u'not contains')
-        ],
-        u'Model1 / Test4': [
-            (12, u'equals'),
-            (13, u'not equal'),
-            (14, u'contains'),
-            (15, u'not contains')
-        ],
-        u'Model1 / Bool Field': [
-            (16, u'equals'),
-            (17, u'not equal'),
-        ],
-        u'Model1 / Enum Field': [
-            (18, u'equals'),
-            (19, u'not equal'),
-        ]})
+
+    eq_([ (f['label'], f['operation']) for f in view._flattened_filters_by_group['Model1 / Test1'] ],
+        [('0', u'equals'),
+         ('1', u'not equal'),
+         ('2', u'contains'),
+         ('3', u'not contains')])
+    eq_([ (f['label'], f['operation']) for f in view._flattened_filters_by_group['Model1 / Test2'] ],
+        [('4', u'equals'),
+         ('5', u'not equal'),
+         ('6', u'contains'),
+         ('7', u'not contains')])
+    eq_([ (f['label'], f['operation']) for f in view._flattened_filters_by_group['Model1 / Test3'] ],
+        [('8', u'equals'),
+         ('9', u'not equal'),
+         ('10', u'contains'),
+         ('11', u'not contains')])
+    eq_([ (f['label'], f['operation']) for f in view._flattened_filters_by_group['Model1 / Test4'] ],
+        [('12', u'equals'),
+         ('13', u'not equal'),
+         ('14', u'contains'),
+         ('15', u'not contains')])
+    eq_([ (f['label'], f['operation']) for f in view._flattened_filters_by_group['Model1 / Bool Field'] ],
+        [('16', u'equals'),
+         ('17', u'not equal')])
+    eq_([ (f['label'], f['operation']) for f in view._flattened_filters_by_group['Model1 / Enum Field'] ],
+        [('18', u'equals'),
+         ('19', u'not equal')])
+
 
     # Test filter with a dot
     view = CustomModelView(Model2, db.session,
                            column_filters=['model1.bool_field'])
 
-    eq_(view._filter_dict, {
-        'Model1 / Bool Field': [
-            (0, 'equals'),
-            (1, 'not equal'),
-        ]})
+    eq_([ (f['label'], f['operation']) for f in view._flattened_filters_by_group['Model1 / Bool Field'] ],
+        [('0', u'equals'),
+         ('1', u'not equal')])
 
     # Fill DB
     model1_obj1 = Model1('model1_obj1', bool_field=True)
@@ -324,9 +315,11 @@ def test_column_filters():
                            column_filters=['int_field'])
     admin.add_view(view)
 
-    eq_(view._filter_dict, {'Int Field': [(0, 'equals'), (1, 'not equal'),
-                                          (2, 'greater than'), (3, 'smaller than')]})
-
+    eq_([ (f['label'], f['operation']) for f in view._flattened_filters_by_group['Int Field'] ],
+        [('0', u'equals'),
+         ('1', u'not equal'),
+         ('2', u'greater than'),
+         ('3', u'smaller than')])
 
     #Test filters to joined table field
     view = CustomModelView(

flask_admin/tests/test_model.py

@@ -302,8 +302,8 @@ def test_column_filters():
     eq_(view._filters[0].name, 'col1')
     eq_(view._filters[1].name, 'col2')
 
-    eq_(view._filter_dict, {'col1': [(0, 'test')],
-                            'col2': [(1, 'test')]})
+    eq_([ (f['label'], f['operation']) for f in view._flattened_filters_by_group['col1'] ], [('0', 'test')])
+    eq_([ (f['label'], f['operation']) for f in view._flattened_filters_by_group['col2'] ], [('1', 'test')])
 
     # TODO: Make calls with filters