it-swarm.com.de

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.

422
Switch

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 so zurückgeben:

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

Verwenden Sie für Django 1.7+ JsonResponse wie in diese SO Antwort wie folgt:

from Django.http import JsonResponse
return JsonResponse({'foo':'bar'})
867
Tom

Neu in Django 1.7

sie könnten JsonResponse Objekte verwenden.

aus den Dokumenten:

from Django.http import JsonResponse
return JsonResponse({'foo':'bar'})
151
srj

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 JsonResponse wurden Objekte zum Django Framework hinzugefügt, was diese Aufgabe noch einfacher macht:

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

Seit Django 1.7 haben Sie einen Standard JsonResponse genau das, was Sie brauchen:

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

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

23
Akhorus
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)
15

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

14
Andres

Sie möchten 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")
10
ReduxDJ

Mit Django Klassenbasierten 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'})
7
elim

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')
5
Tanmay D

Wie benutzt man 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)
5
Samiro

Dies ist meine bevorzugte Version, die eine klassenbasierte Ansicht verwendet. Unterklassen Sie einfach die Basisansicht und überschreiben Sie die get () - Methode.

import json

class MyJsonView(View):

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

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>
3
Rajan Mandanka

Zuerst importiere dies:

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

In View verwenden Sie Folgendes:

form.field.errors|striptags

um Validierungsnachrichten ohne HTML zu erhalten

0
Deepak Sharma