Ticket #1410: paginate_multiple_v2.diff

File paginate_multiple_v2.diff, 7.0 kB (added by beef, 1 year ago)

Second, better version of the patch.

  • paginate.py

    old new  
    6767    ''' 
    6868    def entangle(func): 
    6969        def decorated(func, *args, **kw): 
    70             page = int(kw.pop('tg_paginate_no', 1)) 
    71             limit_ = int(kw.pop('tg_paginate_limit', limit)) 
    72             order = kw.pop('tg_paginate_order', None) 
    73             ordering = kw.pop('tg_paginate_ordering', {}) 
     70            def kwpop(default, *names): 
     71                for name in names: 
     72                    if kw.has_key(name): 
     73                        return kw.pop(name) 
     74                return default 
    7475 
     76            page = int(kwpop(1, var_name + '_tgp_no', 'tg_paginate_no')) 
     77            limit_ = int( 
     78                kwpop(limit, var_name + '_tgp_limit', 'tg_paginate_limit')) 
     79            order = kwpop(None, var_name + '_tgp_order', 'tg_paginate_order') 
     80            ordering = kwpop( 
     81                {}, 
     82                var_name + '_tgp_ordering', 
     83                'tg_paginate_ordering') 
     84 
    7585            # Convert ordering str to a dict. 
    7686            if ordering: 
    7787                ordering = convert_ordering(ordering) 
    …… 
    161171            input_values =  variable_encode(cherrypy.request.params.copy()) 
    162172            input_values.pop('self', None) 
    163173            for input_key in input_values.keys(): 
    164                 if input_key.startswith('tg_paginate'): 
     174                if input_key.startswith(var_name + '_tgp') or \ 
     175                    input_key.startswith('tg_paginate'): 
    165176                    del input_values[input_key] 
    166177 
    167             cherrypy.request.paginate = Paginate(current_page=page, 
    168                                              limit=limit_, 
    169                                              pages=pages_to_show, 
    170                                              page_count=page_count, 
    171                                              input_values=input_values, 
    172                                              order=order, 
    173                                              ordering=ordering, 
    174                                              row_count=row_count) 
     178            paginate_instance = Paginate( 
     179                current_page=page, 
     180                limit=limit_,  
     181                pages=pages_to_show,  
     182                page_count=page_count,  
     183                input_values=input_values,  
     184                order=order, 
     185                ordering=ordering, 
     186                row_count=row_count, 
     187                var_name=var_name) 
    175188 
     189            cherrypy.request.paginate = paginate_instance 
     190            if not hasattr(cherrypy.request, 'paginates'): 
     191                cherrypy.request.paginates = dict() 
     192            cherrypy.request.paginates[var_name] = paginate_instance 
     193 
    176194            # we replace the var with the sliced one 
    177195            endpoint = offset + limit_ 
    178196            log.debug("slicing data between %d and %d", offset, endpoint) 
    …… 
    188206    paginate = getattr(cherrypy.request, 'paginate', None) 
    189207    if paginate: 
    190208        d.update(dict(paginate=paginate)) 
     209    paginates = getattr(cherrypy.request, 'paginates', None) 
     210    if paginates: 
     211        d.update(dict(paginates=paginates)) 
    191212variable_providers.append(_paginate_var_provider) 
    192213 
    193214class Paginate: 
    194215    """class for variable provider""" 
    195     def __init__(self, current_page, pages, page_count, input_values, 
    196                  limit, order, ordering, row_count): 
    197  
     216    def __init__(self, current_page, pages, page_count, input_values,  
     217                 limit, order, ordering, row_count, var_name): 
     218                  
     219        self.var_name = var_name 
    198220        self.pages = pages 
    199221        self.limit = limit 
    200222        self.page_count = page_count 
    …… 
    213235                self.reversed = True 
    214236 
    215237        # If ordering is empty, don't add it. 
    216         input_values = dict(tg_paginate_limit=limit) 
     238        input_values = {var_name + '_tgp_limit': limit} 
    217239        if ordering: 
    218             input_values['tg_paginate_ordering'] = ordering 
     240            input_values[var_name + '_tgp_ordering'] = ordering 
    219241        self.input_values.update(input_values) 
    220242 
    221243        if current_page < page_count: 
    222             self.input_values.update(dict( 
    223                                 tg_paginate_no=current_page+1, 
    224                                 tg_paginate_limit=limit)) 
    225             self.href_next = turbogears.url(cherrypy.request.path, 
    226                                             self.input_values) 
    227             self.input_values.update(dict( 
    228                                 tg_paginate_no=page_count, 
    229                                 tg_paginate_limit=limit)) 
    230             self.href_last = turbogears.url(cherrypy.request.path, 
    231                                             self.input_values) 
     244            self.input_values.update({ 
     245                var_name + '_tgp_no': current_page + 1, 
     246                var_name + '_tgp_limit': limit 
     247            }) 
     248            self.href_next = turbogears.url( 
     249                cherrypy.request.path, 
     250                self.input_values) 
     251            self.input_values.update({ 
     252                var_name + '_tgp_no': page_count, 
     253                var_name + '_tgp_limit': limit 
     254            }) 
     255            self.href_last = turbogears.url( 
     256                cherrypy.request.path, 
     257                self.input_values) 
    232258        else: 
    233259            self.href_next = None 
    234260            self.href_last = None 
    235261 
    236262        if current_page > 1: 
    237             self.input_values.update(dict( 
    238                                 tg_paginate_no=current_page-1, 
    239                                 tg_paginate_limit=limit)) 
    240             self.href_prev = turbogears.url(cherrypy.request.path, 
    241                                             self.input_values) 
    242             self.input_values.update(dict( 
    243                                 tg_paginate_no=1, 
    244                                 tg_paginate_limit=limit)) 
    245             self.href_first = turbogears.url(cherrypy.request.path, 
    246                                              self.input_values) 
     263            self.input_values.update({ 
     264                var_name + '_tgp_no': current_page - 1, 
     265                var_name + '_tgp_limit': limit 
     266            }) 
     267            self.href_prev = turbogears.url( 
     268                cherrypy.request.path, 
     269                self.input_values) 
     270            self.input_values.update({ 
     271                var_name + '_tgp_no': 1, 
     272                var_name + '_tgp_limit': limit 
     273            }) 
     274            self.href_first = turbogears.url( 
     275                cherrypy.request.path, 
     276                self.input_values) 
    247277        else: 
    248278            self.href_prev = None 
    249279            self.href_first = None 
    …… 
    253283        # and in the template.  I'm not removing it now because I don't want 
    254284        # to break the API. 
    255285        order = order or None 
    256         self.input_values['tg_paginate_no'] = page 
     286        self.input_values[self.var_name + '_tgp_no'] = page 
    257287        if order: 
    258             self.input_values['tg_paginate_order'] = order 
     288            self.input_values[self.var_name + '_tgp_order'] = order 
    259289 
    260290        return turbogears.url('', self.input_values) 
    261291