Wie kann ich JSON zurückgeben, ohne eine Vorlage in Django zu verwenden?

Dies hängt mit dieser Frage zusammen: Django gibt je nach Client-Python json und html zurück

Ich habe eine Befehlszeilen-Python-API für eine Django-App. Wenn ich über die API auf die App zugreife, sollte sie JSON und mit einem Browser HTML zurückgeben. Ich kann verschiedene URLs verwenden, um auf die verschiedenen Versionen zuzugreifen. Wie kann ich jedoch die HTML-Vorlage und JSON in der Datei views.py mit nur einer Vorlage rendern ?

Um den HTML-Code zu rendern, würde ich Folgendes verwenden:

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

Aber wie würde ich dasselbe für JSON tun, ohne eine JSON-Vorlage einzufügen? (das content-typesollte application/jsonstatt sein text/html)

Was würde die JSON- und HTML-Ausgaben bestimmen?

Also aus meiner Sicht .

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

Ich denke, das Problem ist verwirrt, was Sie wollen. Ich kann mir vorstellen, dass Sie nicht wirklich versuchen, den HTML-Code in die JSON-Antwort einzufügen, sondern alternativ entweder HTML oder JSON zurückgeben möchten.

Zunächst müssen Sie den Kernunterschied zwischen den beiden verstehen. HTML ist ein Präsentationsformat. Es geht mehr um die Anzeige von Daten als um die Daten selbst. JSON ist das Gegenteil. Es sind reine Daten - im Grunde eine JavaScript-Darstellung eines Python-Datensatzes (in diesem Fall), den Sie haben. Es dient lediglich als Austauschschicht, mit der Sie Daten aus einem Bereich Ihrer App (der Ansicht) in einen anderen Bereich Ihrer App (Ihr JavaScript) verschieben können, die normalerweise keinen Zugriff aufeinander haben.

In diesem Sinne "rendern" Sie JSON nicht und es sind keine Vorlagen beteiligt. Sie konvertieren lediglich alle im Spiel befindlichen Daten (höchstwahrscheinlich so ziemlich das, was Sie als Kontext an Ihre Vorlage übergeben) in JSON. Dies kann entweder über die JSON-Bibliothek von Django (simplejson) erfolgen, wenn es sich um Freiformdaten handelt, oder über das Serialisierungsframework, wenn es sich um ein Abfrageset handelt.

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)

Serialisierung

from django.core import serializers

foos = Foo.objects.all()

data = serializers.serialize('json', foos)

In beiden Fällen übergeben Sie diese Daten dann an die Antwort:

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

[Bearbeiten] In Django 1.6 und früheren Versionen war der Code für die Rückgabe der Antwort

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

In Django 1.7 ist dies mit der integrierten JsonResponse noch einfacher.

https://docs.djangoproject.com/de/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)

Bei der JSON-Antwort muss keine Vorlage gerendert werden. Vorlagen dienen zum Generieren von HTML-Antworten. Der JSON ist die HTTP-Antwort.

Sie können jedoch HTML verwenden, das mit Ihrer JSON-Antwort aus einer Vorlage gerendert wird.

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

Es sieht so aus, als ob das Django REST-Framework den HTTP-Accept-Header in einer Anfrage verwendet, um automatisch zu bestimmen, welcher Renderer verwendet werden soll:

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

Die Verwendung des HTTP-Accept-Headers bietet möglicherweise eine alternative Quelle für Ihr "Wenn etwas".

Um meine Modelle in JSON in Django 1.9 zu rendern, musste ich in meinen views.py Folgendes tun:

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')

Sie können auch überprüfen, ob die Anforderung den Inhaltstyp akzeptiert, wie im RFC angegeben. Auf diese Weise können Sie standardmäßig HTML rendern und wenn Ihr Client Anwendung / Jason akzeptiert, können Sie json in Ihrer Antwort zurückgeben, ohne dass eine Vorlage erforderlich ist

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')

Hier ist ein Beispiel, das ich zum bedingten Rendern von JSON oder HTML je nach AcceptHeader der Anforderung benötigte

# 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)

Sie können dies mit Curl oder httpie testen

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

Hinweis Ich habe mich für JsonReponsedie Nichtverwendung entschieden, da dies das Modell unnötig reserialisieren würde .

Wenn Sie das Ergebnis als gerenderte Vorlage übergeben möchten, müssen Sie eine Vorlage laden und rendern. Übergeben Sie das Ergebnis des Renderns an json. Dies könnte folgendermaßen aussehen:

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)

Auf diese Weise können Sie eine gerenderte Vorlage als JSON an Ihren Client übergeben. Dies kann nützlich sein, wenn Sie vollständig ersetzen möchten, z. a enthält viele verschiedene Elemente.