Erstellen einer JSON-Antwort mit Django und Python

Ich versuche, ein serverseitiges Ajax-Antwortskript in eine Django HttpResponse zu konvertieren, aber anscheinend funktioniert es nicht.

Dies ist das serverseitige Skript:

/* RECEIVE VALUE */
$validateValue=$_POST['validateValue'];
$validateId=$_POST['validateId'];
$validateError=$_POST['validateError'];

/* RETURN VALUE */
$arrayToJs = array();
$arrayToJs[0] = $validateId;
$arrayToJs[1] = $validateError;

if($validateValue =="Testuser"){  // Validate??
    $arrayToJs[2] = "true";       // RETURN TRUE
    echo '{"jsonValidateReturn":'.json_encode($arrayToJs).'}';  // RETURN ARRAY WITH success
}
else{
    for($x=0;$x<1000000;$x++){
        if($x == 990000){
            $arrayToJs[2] = "false";
            echo '{"jsonValidateReturn":'.json_encode($arrayToJs).'}';   // RETURNS ARRAY WITH ERROR.
        }
    }
}

Und das ist der konvertierte Code

def validate_user(request):
    if request.method == 'POST':
        vld_value = request.POST.get('validateValue')
        vld_id = request.POST.get('validateId')
        vld_error = request.POST.get('validateError')

        array_to_js = [vld_id, vld_error, False]

        if vld_value == "TestUser":
            array_to_js[2] = True
            x = simplejson.dumps(array_to_js)
            return HttpResponse(x)
        else:
            array_to_js[2] = False
            x = simplejson.dumps(array_to_js)
            error = 'Error'
            return render_to_response('index.html',{'error':error},context_instance=RequestContext(request))
    return render_to_response('index.html',context_instance=RequestContext(request))

Ich verwende simplejson, um die Python-Liste zu codieren (damit ein JSON-Array zurückgegeben wird). Ich konnte das Problem noch nicht herausfinden. Aber ich denke, dass ich etwas falsch gemacht habe mit dem 'Echo'.

Normalerweise verwende ich ein Wörterbuch und keine Liste, um JSON-Inhalte zurückzugeben.

import json

from django.http import HttpResponse

response_data = {}
response_data['result'] = 'error'
response_data['message'] = 'Some error message'

Pre-Django 1.7 würden Sie es wie folgt zurückgeben:

return HttpResponse(json.dumps(response_data), content_type="application/json")

Verwenden Sie für Django 1.7+ JsonResponsewie in dieser SO-Antwort gezeigt wie folgt :

from django.http import JsonResponse
return JsonResponse({'foo':'bar'})

Neu in Django 1.7

Sie können JsonResponse- Objekte verwenden.

aus den Dokumenten:

from django.http import JsonResponse
return JsonResponse({'foo':'bar'})

Ich benutze das, es funktioniert gut.

from django.utils import simplejson
from django.http import HttpResponse

def some_view(request):
    to_json = {
        "key1": "value1",
        "key2": "value2"
    }
    return HttpResponse(simplejson.dumps(to_json), mimetype='application/json')

Alternative:

from django.utils import simplejson

class JsonResponse(HttpResponse):
    """
        JSON response
    """
    def __init__(self, content, mimetype='application/json', status=None, content_type=None):
        super(JsonResponse, self).__init__(
            content=simplejson.dumps(content),
            mimetype=mimetype,
            status=status,
            content_type=content_type,
        )

In Django 1.7 wurden JsonResponse- Objekte zum Django-Framework selbst hinzugefügt, was diese Aufgabe noch einfacher macht:

from django.http import JsonResponse
def some_view(request):
    return JsonResponse({"key": "value"})

Seit Django 1.7 haben Sie eine Standard- JsonResponse , die genau das ist, was Sie brauchen:

from django.http import JsonResponse
...
return JsonResponse(array_to_js, safe=False)

Sie müssen nicht einmal Ihr Array json.dump.

from django.http import HttpResponse
import json

class JsonResponse(HttpResponse):
    def __init__(self, content={}, mimetype=None, status=None,
             content_type='application/json'):
        super(JsonResponse, self).__init__(json.dumps(content), mimetype=mimetype,
                                           status=status, content_type=content_type)

Und in der Ansicht:

resp_data = {'my_key': 'my value',}
return JsonResponse(resp_data)

Für diejenigen, die Django 1.7+ verwenden

from django.http import JsonResponse

def your_view(request):
    json_object = {'key': "value"}
    return JsonResponse(json_object)

offizielle Dokumente

Sie sollten den Django-Serializer verwenden, um bei Unicode-Dingen zu helfen:

from django.core import serializers

json_serializer = serializers.get_serializer("json")()
    response =  json_serializer.serialize(list, ensure_ascii=False, indent=2, use_natural_keys=True)
    return HttpResponse(response, mimetype="application/json")

Mit Django Class-basierten Ansichten können Sie schreiben:

from django.views import View
from django.http import JsonResponse

class JsonView(View):
    def get(self, request):
        return JsonResponse({'some': 'data'})

und mit Django-Rest-Framework können Sie schreiben:

from rest_framework.views import APIView
from rest_framework.response import Response

class JsonView(APIView):
    def get(self, request):
        return Response({'some': 'data'})

Es ist sehr praktisch mit Django Version 1.7 oder höher, da Sie die JsonResponse-Klasse haben, die eine Unterklasse von HttpResponse ist.

from django.http import JsonResponse
    def profile(request):
        data = {
            'name': 'Raghav',
            'location': 'India',
            'is_active': False,
            'count': 28
        }
        return JsonResponse(data)

Für ältere Versionen von Django müssen Sie ein HttpResponse-Objekt verwenden.

import json
from django.http import HttpResponse

def profile(request):
    data = {
        'name': 'Raghav',
        'location': 'India',
        'is_active': False,
        'count': 28
    }
    dump = json.dumps(data)
    return HttpResponse(dump, content_type='application/json')

Wie verwende ich die Google App Engine mit Ajax (JSON)?

Code Javascript mit JQuery:

$.ajax({
    url: '/ajax',
    dataType : 'json',
    cache: false,
    success: function(data) {
        alert('Load was performed.'+data.ajax_resp);
    }
});

Code Python

class Ajax(webapp2.RequestHandler):
    def get(self):
        my_response = {'ajax_resp':'Hello, webapp World!'}
        datos = json.dumps(my_response)

        self.response.headers.add_header('content-type', 'application/json', charset='utf-8')
        self.response.out.write(datos)

Dies ist meine bevorzugte Version mit einer klassenbasierten Ansicht. Unterklassifizieren Sie einfach die Basisansicht und überschreiben Sie die Methode get () -.

import json

class MyJsonView(View):

    def get(self, *args, **kwargs):
        resp = {'my_key': 'my value',}
        return HttpResponse(json.dumps(resp), mimetype="application/json" )

Django-Code views.py:

def view(request):
    if request.method == 'POST':
        print request.body
        data = request.body
        return HttpResponse(json.dumps(data))

HTML-Code view.html:

<!DOCTYPE html>
<html>
<head>
<script src="http://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js"></script>
<script>
$(document).ready(function(){
    $("#mySelect").change(function(){
        selected = $("#mySelect option:selected").text()
        $.ajax({
            type: 'POST',
            dataType: 'json',
            contentType: 'application/json; charset=utf-8',
            url: '/view/',
            data: {
                    'fruit': selected
                  },
            success: function(result) {
                        document.write(result)
                    }
    });
  });
});
</script>
</head>
<body>

<form>
    {{data}}
    <br>
Select your favorite fruit:
<select id="mySelect">
  <option value="apple" selected >Select fruit</option>
  <option value="apple">Apple</option>
  <option value="orange">Orange</option>
  <option value="pineapple">Pineapple</option>
  <option value="banana">Banana</option>
</select>
</form>
</body>
</html>

Importieren Sie zuerst Folgendes:

from django.http import HttpResponse

Wenn Sie den JSON bereits haben:

def your_method(request):
    your_json = [{'key1': value, 'key2': value}]
    return HttpResponse(your_json, 'application/json')

Wenn Sie den JSON von einer anderen HTTP-Anforderung erhalten:

def your_method(request):
    response = request.get('https://www.example.com/get/json')
    return HttpResponse(response, 'application/json')

Verwenden Sie JsonResponse

from django.http import JsonResponse

Verwenden Sie in der Ansicht Folgendes:

form.field.errors|striptags

zum Abrufen von Validierungsnachrichten ohne HTML