Wie paginiere ich Django mit anderen Variablen?

Ich dachte, die benutzerdefinierte tags, die vorgeschlagen wurden, sind zu Komplex, das ist, was ich getan habe in der Vorlage:

<a href="?{% url_replace request 'page' paginator.next_page_number %}">

Und die tag-Funktion:

@register.simple_tag
def url_replace(request, field, value):

    dict_ = request.GET.copy()

    dict_[field] = value

    return dict_.urlencode()

Wenn die url_param ist noch nicht in der url, es wird Hinzugefügt werden mit dem Wert. Wenn es schon da ist, wird es ersetzt durch den neuen Wert. Dies ist eine einfache Lösung die zu mir passt, aber nicht funktioniert, wenn die url hat mehrere Parameter mit dem gleichen Namen.

Müssen Sie auch die RequestContext-request-Instanz bereitgestellt werden, um Ihre Vorlage aus Ihrer Sicht. Mehr info hier:

http://lincolnloop.com/blog/2008/may/10/getting-requestcontext-your-templates/

InformationsquelleAutor der Antwort mpaf

Nach einigem Herumspielen habe ich eine Lösung gefunden... obwohl ich nicht weiß, ob es wirklich gut. Ich würde lieber eine elegante Lösung.

Trotzdem gebe ich die Anfrage an die Vorlage und bin in der Lage, Zugriff auf alle GET-Variablen via Anfrage.BEKOMMEN. Dann habe ich eine Schleife durch die GET-Wörterbuch und solange die variable nicht Seite, die ich drucken.

{% if contacts.has_previous %}
    <a href="?page={{ contacts.previous_page_number }}{% for key,value in request.GET.items %}{% ifnotequal key 'page' %}&{{ key }}={{ value }}{% endifnotequal %}{% endfor %}">previous</a>
{% endif %}

<span class="current">
    Page {{ contacts.number }} of {{ contacts.paginator.num_pages }}.
</span>

{# I have all of this in one line in my code (like in the previous section), but I'm putting spaces here for readability.  #}
{% if contacts.has_next %}
    <a href="?page={{ contacts.next_page_number }}
        {% for key,value in request.GET.items %}
            {% ifnotequal key 'page' %}
                &{{ key }}={{ value }}
            {% endifnotequal %}
        {% endfor %}
    ">next</a>
{% endif %}

InformationsquelleAutor der Antwort vagabond

Kann man einen Kontext-Prozessor zu verwenden, wenn die Paginierung angewendet wird.

Beispielsweise in my_project/my_app/context_processors.py:

def getvars(request):
    """
    Builds a GET variables string to be uses in template links like pagination
    when persistence of the GET vars is needed.
    """
    variables = request.GET.copy()

    if 'page' in variables:
        del variables['page']

    return {'getvars': '&{0}'.format(variables.urlencode())}

Fügen Sie das Kontext-Prozessor, um Ihre Django Projekt-Einstellungen:

TEMPLATE_CONTEXT_PROCESSORS = (
    'django.contrib.auth.context_processors.auth',
    'django.contrib.messages.context_processors.messages',
    'django.core.context_processors.i18n',
    'django.core.context_processors.request',
    'django.core.context_processors.media',
    'django.core.context_processors.static',
     ...
    'my_project.my_app.context_processors.getvars',
)

Dann, in Ihren Vorlagen verwenden, können Sie diese beim umbrechen:

<div class="row">
    {# Initial/backward buttons #}
    <div class="col-xs-4 col-md-4 text-left">
        <a href="?page=1{{ getvars }}" class="btn btn-rounded">{% trans 'first' %}</a>
        {% if page_obj.has_previous %}
            <a href="?page={{ page_obj.previous_page_number }}{{ getvars }}" class="btn btn-rounded">{% trans 'previous' %}</a>
        {% endif %}
    </div>

    {# Page selection by number #}
    <div class="col-xs-4 col-md-4 text-center content-pagination">
        {% for page in page_obj.paginator.page_range %}
            {% ifequal page page_obj.number %}
                <a class="active">{{ page }}</a>
            {% else %}
                <a href="?page={{ page }}{{ getvars }}">{{ page }}</a>
            {% endifequal %}
        {% endfor %}
    </div>

    {# Final/forward buttons #}
    <div class="col-xs-4 col-md-4 text-right">
        {% if page_obj.has_next %}
            <a href="?page={{ page_obj.next_page_number }}{{ getvars }}" class="btn btn-rounded">{% trans 'next' %}</a>
        {% endif %}
        <a href="?page={{ paginator.num_pages }}{{ getvars }}" class="btn btn-rounded">{% trans 'last' %}</a>
    </div>
</div>

Was GET-Variablen Sie haben in Ihrer Anfrage, Sie wird angehängt, nachdem der ?page= GET-parameter.

InformationsquelleAutor der Antwort José L. Patiño

Hier ist eine nützliche benutzerdefinierte template-tag für den Bau von query-strings.

<a href="?{% make_query_string page=obj_list.next_page_number %}">Next page</a>

Wenn die URL http://example.com/django/page/?search=sometextder generierte HTML-Code sollte so etwas wie:

<a href="?search=sometext&page=2">Next page</a>

Weitere Beispiele:

<!-- Original URL -->
<!-- http://example.com/django/page/?page=1&item=foo&item=bar -->

<!-- Add or replace arguments -->
{% make_query_string page=2 item="foo2" size=10 %}
<!-- Result: page=2&item=foo2&size=10 -->

<!-- Append arguments -->
{% make_query_string item+="foo2" item+="bar2" %}
<!-- Result: page=1&item=foo&item=bar&item=foo2&item=bar2 -->

<!-- Remove a specific argument -->
{% make_query_string item-="foo" %}
<!-- Result: page=1&item=bar -->

<!-- Remove all arguments with a specific name -->
{% make_query_string item= %}
<!-- Result: page=1 -->

Schließlich den Quellcode (geschrieben von mir):

# -*- coding: utf-8 -*-
from django import template
from django.utils.encoding import force_text  # Django 1.5+ only

register = template.Library()


class QueryStringNode(template.Node):
    def __init__(self, tag_name, parsed_args, var_name=None, silent=False):
        self.tag_name = tag_name
        self.parsed_args = parsed_args
        self.var_name = var_name
        self.silent = silent

    def render(self, context):
        # django.core.context_processors.request should be enabled in
        # settings.TEMPLATE_CONTEXT_PROCESSORS.
        # Or else, directly pass the HttpRequest object as 'request' in context.
        query_dict = context['request'].GET.copy()
        for op, key, value in self.parsed_args:
            if op == '+':
                query_dict.appendlist(key, value.resolve(context))
            elif op == '-':
                list_ = query_dict.getlist(key)
                value_ = value.resolve(context)
                try:
                    list_.remove(value_)
                except ValueError:
                    # Value not found
                    if not isinstance(value_, basestring):
                        # Try to convert it to unicode, and try again
                        try:
                            list_.remove(force_text(value_))
                        except ValueError:
                            pass
            elif op == 'd':
                try:
                    del query_dict[key]
                except KeyError:
                    pass
            else:
                query_dict[key] = value.resolve(context)
        query_string = query_dict.urlencode()
        if self.var_name:
            context[self.var_name] = query_string
        if self.silent:
            return ''
        return query_string


@register.tag
def make_query_string(parser, token):
    # {% make_query_string page=1 size= item+="foo" item-="bar" as foo [silent] %}
    args = token.split_contents()
    tag_name = args[0]
    as_form = False
    if len(args) > 3 and args[-3] == "as":
        # {% x_make_query_string ... as foo silent %} case.
        if args[-1] != "silent":
            raise template.TemplateSyntaxError(
                "Only 'silent' flag is allowed after %s's name, not '%s'." %
                (tag_name, args[-1]))
        as_form = True
        silent = True
        args = args[:-1]
    elif len(args) > 2 and args[-2] == "as":
        # {% x_make_query_string ... as foo %} case.
        as_form = True
        silent = False

    if as_form:
        var_name = args[-1]
        raw_pairs = args[1:-2]
    else:
        raw_pairs = args[1:]

    parsed_args = []
    for pair in raw_pairs:
        try:
            arg, raw_value = pair.split('=', 1)
        except ValueError:
            raise template.TemplateSyntaxError(
                "%r tag's argument should be in format foo=bar" % tag_name)
        operator = arg[-1]
        if operator == '+':
            # item+="foo": Append to current query arguments.
            # e.g. item=1 -> item=1&item=foo
            parsed_args.append(('+', arg[:-1], parser.compile_filter(raw_value)))
        elif operator == '-':
            # item-="bar": Remove from current query arguments.
            # e.g. item=1&item=bar -> item=1
            parsed_args.append(('-', arg[:-1], parser.compile_filter(raw_value)))
        elif raw_value == '':
            # item=: Completely remove from current query arguments.
            # e.g. item=1&item=2 -> ''
            parsed_args.append(('d', arg, None))
        else:
            # item=1: Replace current query arguments, e.g. item=2 -> item=1
            parsed_args.append(('', arg, parser.compile_filter(raw_value)))

    if as_form:
        node = QueryStringNode(tag_name, parsed_args,
                               var_name=var_name, silent=silent)
    else:
        node = QueryStringNode(tag_name, parsed_args)

    return node

InformationsquelleAutor der Antwort Rockallite

Verbesserung der diese von:

Verwenden urlencode aus django statt urllibum zu verhindern, dass UnicodeEncodeError Fehler mit unicode Argumente.

Template-tag:

from django.utils.http import urlencode

@register.simple_tag(takes_context=True)
def url_replace(context, **kwargs):
    query = context['request'].GET.dict()
    query.update(kwargs)
    return urlencode(query)

Vorlage:

<!-- Pagination -->
<div class="pagination">
 <span class="step-links">
   {% if coupons.has_previous %}
    <a href="?{% url_replace page=objects.previous_page_number %}">Prev</a>
   {% endif %}
   <span class="current">
    Page {{ objects.number }} of {{ objects.paginator.num_pages }}
   </span>
   {% if objects.has_next %}
    <a href="?{% url_replace page=objects.next_page_number %}">Next</a>
   {% endif %}
  </span>
</div>

InformationsquelleAutor der Antwort Omid Raha

'path': request.get_full_path().rsplit('&page')[0],

InformationsquelleAutor der Antwort

Werden Sie zurückgeben müssen, ERHALTEN Sie so oben angegeben. Sie können übergeben, die GET-Anforderung " - Teil der url durch den Aufruf

render_dict['GET'] = request.GET.urlencode(True)
return render_to_response('search/search.html',
                          render_dict,
                          context_instance=RequestContext(request))

dann können Sie dies in der Vorlage erstellen Sie Ihre URL z.B.

href="/search/client/{{ page.no }}/10/?{{ GET }}

InformationsquelleAutor der Antwort ajaali

Anderes nehmen auf die url_encode Lösung, in diesem Fall vereinfacht, indem skoval00.

Hatte ich ein paar Probleme mit dieser version. Ein, es hatte nicht die Unterstützung der Unicode-Codierung und zwei, es brach für Filter mit mehreren gleichen keys (wie ein MultipleSelect widget). Wegen der .dict () - Konvertierung, alle Werte aber sind verloren. Meine version unterstützt unicode und mehrere mit dem gleichen key:

from django import template
from django.utils.html import mark_safe

register = template.Library()

@register.simple_tag(takes_context=True)
def url_replace(context, **kwargs):
    query = context['request'].GET.copy()

    for kwarg in kwargs:
        try:
            query.pop(kwarg)
        except KeyError:
            pass

    query.update(kwargs)

    return mark_safe(query.urlencode())

Dies schafft eine QueryDict kopieren, dann entfernt alle Schlüssel, die entsprechen, kwargs (seit update für eine QueryDict ergänzt, statt Sie zu ersetzen). Mark_safe nötig war, durch eine doppelte Codierung Problem.

Verwenden Sie es wie folgt aus (vergessen Sie nicht, laden Sie die tags):

<a class="next" href="?{% url_replace p=objects.next_page_number%}">Next</a>

wo ?p=1 ist unsere Seitenumbrüche syntax in der Ansicht.

InformationsquelleAutor der Antwort Apollo Data