Django: etiqueta de inclusión de representación desde una vista

Question

, por lo que me preguntaba si podría devolver una etiqueta de inclusión directamente desde una vista.

La página es una página normal con una lista de elementos. La lista de elementos se representa con una etiqueta de inclusión. Si se realiza una solicitud de AJAX a la vista, quiero devolver solo lo que devolvería la etiqueta de inclusión para poder agregarla a la página a través de JavaScript. Es algo como esto posible? ¿O debería diseñar esto mejor?

Answer 1

Esto es ciertamente posible. Una vista puede representar cualquier plantilla que pueda contener una etiqueta de inclusión. La ventaja de este enfoque es que puede aprovechar toda la fortaleza de las plantillas de Django.

Por otro lado, las respuestas AJAX normalmente no contienen HTML tanto como XML/JSON. Si está utilizando las características de la plantilla de Django, es mejor devolver el HTML. De lo contrario, XML/JSON podría tener más sentido. Solo mis dos centavos.

Answer 2

manera rápida y sucia podría ser para tener una vista, que rinde una plantilla, que solo contiene su templatetag.

Answer 3

yo estaba tratando de hacer exactamente lo mismo hoy, y terminé escribiendo una función de ayuda para hacer etiquetas de plantilla:

def render_templatetag(request, tag_string, tag_file, dictionary=None): 
    dictionary = dictionary or {} 
    context_instance = RequestContext(request) 
    context_instance.update(dictionary) 
    t = Template("{%% load %s %%}{%% %s %%}" % (tag_file, tag_string)) 
    return t.render(context_instance) 

tag_string es la llamada a la etiqueta de plantilla, ya que aparecerían en una normalidad plantilla, y tag_file es el archivo que necesita cargar para la etiqueta de la plantilla.

Answer 4

Esto suena como un trabajo para los render_to_string o render_to_response atajos:
https://docs.djangoproject.com/en/dev/ref/templates/api/#the-render-to-string-shortcut
https://docs.djangoproject.com/en/dev/topics/http/shortcuts/#django.shortcuts.render_to_response

todavía podemos utilizar la etiqueta de inclusión para generar un diccionario contexto de la plantilla de nuestros argumentos (como amablemente señalado por @BobStein -VisiBone en los comentarios)

from django.template.loader import render_to_string 
from django.shortcuts import render_to_response 

from .templatetags import my_inclusion_tag 


rendered = render_to_string('my_include.html', my_inclusion_tag(foo='bar')) 

#or 

def my_view(request): 
    if request.is_ajax(): 
     return render_to_response('my_include.html', 
         my_inclusion_tag(foo='bar'), 
         context_instance=RequestContext(request)) 

Answer 5

Usando inclusion tag with configurable template decorator provided by Gonz en lugar de etiquetas de inclusión por defecto de Django puede escribir un ayudante en su opinión:

from django.template.loader import render_to_string 
from home.templatetags.objectwidgets import object_widget 

def _object_widget(request, obj): 
    template, context = object_widget(RequestContext(request), obj) 
    return render_to_string(template, context) 

Es SECO y trabaja con Django 1.3 (no he probado con Django 1.4).

Utilizo esta técnica para devolver los resultados de búsqueda representados en HTML a través de llamadas JSON/AJAX (nada mejor que se me ocurrió).

Answer 6

Es posible, pero probablemente poco hacky, complejo o complicado.

Lo que yo sugeriría es que sea un arquitecto para que tenga la parte de representación en la función utils.py y la use en una etiqueta simple en lugar de una etiqueta_in inclusión. De esta forma, puede usar la misma función de representación de utilidades fácilmente en las vistas.

En mi ejemplo imaginario (muy simplificado) tengo una lista de usuarios y un botón "Cargar más" que devuelve más usuarios.

cuenta/utils.py

from django.template.loader import render_to_string 


def render_users(users): 
    return render_to_string("account/user_list_items.html", {"users": users}) 

cuenta/templatetags/account_tags.py

from django import template 

from ..utils import render_users 

register = template.Library() 


@register.simple_tag 
def list_users(users): 
    return render_users(users) 

cuenta/views.py

from django.http import HttpResponse 

from .models import User 
from .utils import render_users 


def load_more_users(request): 
    limit = request.GET["limit"] 
    offset = request.GET["offset"] 
    users = User.objects.all()[offset:offset + limit] 
    return HttpResponse(render_users(users)) 

simple es mejor que complejo.