por - jquery python ajax tutorial

Django ve regresar json sin usar la plantilla

Question

Esto se relaciona con esta pregunta: Django return json y html dependiendo del cliente python

Tengo una API de línea de comando api para una aplicación django. Cuando accedo a la aplicación a través de la API, debe devolver json y con un navegador debe devolver html. Puedo usar diferentes URL para acceder a las diferentes versiones, pero ¿cómo puedo renderizar la plantilla html y json en views.py con solo una plantilla?

Para renderizar el html usaría:

 return render_to_response(''sample/sample.html....)

¿Pero cómo haría lo mismo para json sin poner una plantilla json? (el tipo de contenido debe ser application / json en lugar de text / html)

Editar 1:

¿Qué determinaría las salidas json y html?

Entonces en mi opinión:

 if something:
return render_to_response(''html_template'',.....)
else:
return HttpReponse(jsondata,mimetype=''application/json'')

Gracias

Answer 1

Aquí hay un ejemplo que necesitaba para representar de forma condicional json o html dependiendo del encabezado Accept la solicitud

# myapp/views.py
from django.core import serializers
from django.http import HttpResponse
from django.shortcuts import render
from .models import Event
def event_index(request):
event_list = Event.objects.all()
if request.META[''HTTP_ACCEPT''] == ''application/json'':
response = serializers.serialize(''json'', event_list)
return HttpResponse(response, content_type=''application/json'')
else:
context = {''event_list'': event_list}
return render(request, ''polls/event_list.html'', context)

puedes probar esto con curl o httpie

$ http localhost:8000/event/
$ http localhost:8000/event/ Accept:application/json

Nota: opté por no usar JsonReponse ya que eso restringiría innecesariamente el modelo .

Answer 2

Creo que el problema se ha confundido con respecto a lo que quieres. Imagino que en realidad no intenta poner el HTML en la respuesta JSON, sino que desea devolver alternativamente HTML o JSON.

Primero, necesitas entender la diferencia principal entre los dos. HTML es un formato de presentación. Se trata más de cómo mostrar los datos que los datos en sí. JSON es lo opuesto. Son datos puros, básicamente una representación de JavaScript de algún conjunto de datos de Python (en este caso). Sirve simplemente como una capa de intercambio, lo que le permite mover datos de un área de su aplicación (la vista) a otra área de su aplicación (su JavaScript) que normalmente no tienen acceso entre sí.

Con eso en mente, no "renderiza" JSON, y no hay plantillas involucradas. Simplemente convierte cualquier información que esté en juego (probablemente más o menos lo que está pasando como el contexto de su plantilla) en JSON. Lo cual se puede hacer a través de la biblioteca JSON de Django (simplejson), si se trata de datos de forma libre, o su marco de serialización, si se trata de un conjunto de consulta.

simplejson

from django.utils import simplejson
some_data_to_dump = {
''some_var_1'': ''foo'',
''some_var_2'': ''bar'',
}
data = simplejson.dumps(some_data_to_dump)

Publicación por entregas

from django.core import serializers
foos = Foo.objects.all()
data = serializers.serialize(''json'', foos)

De cualquier manera, luego pasa esos datos a la respuesta:

return HttpResponse(data, content_type=''application/json'')

[Editar] En Django 1.6 y versiones anteriores, el código para devolver la respuesta era

return HttpResponse(data, mimetype=''application/json'')

Answer 3

En Django 1.7 esto es aún más fácil con la función JsonResponse incorporada.

https://docs.djangoproject.com/en/dev/ref/request-response/#jsonresponse-objects

# import it
from django.http import JsonResponse
def my_view(request):
# do something with the your data
data = {}
# just return a JsonResponse
return JsonResponse(data)

Answer 4

En el caso de la respuesta JSON, no hay plantilla para representar. Las plantillas son para generar respuestas HTML. El JSON es la respuesta HTTP.

Sin embargo, puede tener HTML que se representa desde una plantilla con su respuesta JSON.

html = render_to_string("some.html", some_dictionary)
serialized_data = simplejson.dumps({"html": html})
return HttpResponse(serialized_data, mimetype="application/json")

Answer 5

Para renderizar mis modelos en JSON en django 1.9 tuve que hacer lo siguiente en mi views.py:

from django.core import serializers
from django.http import HttpResponse
from .models import Mymodel
def index(request):
objs = Mymodel.objects.all()
jsondata = serializers.serialize(''json'', objs)
return HttpResponse(jsondata, content_type=''application/json'')

Answer 6

Parece que el marco REST de Django usa el encabezado HTTP accept en una Solicitud para determinar automáticamente qué procesador usar:

http://www.django-rest-framework.org/api-guide/renderers/

El uso del encabezado de HTTP accept puede proporcionar una fuente alternativa para su "si algo".

Answer 7

Si desea pasar el resultado como una plantilla renderizada, debe cargar y representar una plantilla, pase el resultado de renderizarlo a json. Esto podría verse así:

from django.template import loader, RequestContext
#render the template
t=loader.get_template(''sample/sample.html'')
context=RequestContext()
html=t.render(context)
#create the json
result={''html_result'':html)
json = simplejson.dumps(result)
return HttpResponse(json)

De esta forma, puede pasar una plantilla renderizada como json a su cliente. Esto puede ser útil si quiere reemplazar por completo, es decir. a contiene muchos elementos diferentes

Answer 8

También puede verificar que la solicitud acepte el tipo de contenido como se especifica en el rfc. De esta forma, puede representar por defecto HTML y cuando su cliente acepte la aplicación / jason, puede devolver json en su respuesta sin necesidad de una plantilla.

Answer 9

from django.utils import simplejson
from django.core import serializers
def pagina_json(request):
misdatos = misdatos.objects.all()
data = serializers.serialize(''json'', misdatos)
return HttpResponse(data, mimetype=''application/json'')