web-dev-qa-db-fra.com

Création d'une réponse JSON en utilisant Django et Python

J'essaie de convertir un script de réponse Ajax côté serveur en un Django HttpResponse, mais apparemment, cela ne fonctionne pas.

C'est le script côté serveur:

/* 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.
        }
    }
}

Et c'est le code converti

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

J'utilise simplejson pour encoder la liste Python (elle retournera donc un tableau JSON). Je ne pouvais pas encore comprendre le problème. Mais je pense que j'ai fait quelque chose de mal avec "l'écho".

pythondjangojson
422
Switch

J'utilise généralement un dictionnaire et non une liste pour renvoyer du contenu JSON.

import json

from Django.http import HttpResponse

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

Pre-Django 1.7 vous le renverriez comme ceci:

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

Pour Django 1.7+, utilisez JsonResponse comme indiqué dans this SO answer comme suit:

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

Nouveau dans Django 1.7

vous pouvez utiliser JsonResponse objets.

des docs:

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

Je l'utilise, ça marche bien.

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

Dans Django 1.7 JsonResponse , des objets ont été ajoutés au cadre Django, ce qui rend cette tâche encore plus facile:

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

Depuis Django 1.7, vous avez un standard JsonResponse c'est exactement ce dont vous avez besoin:

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

Vous n'avez même pas besoin de json.dump votre tableau.

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)

Et dans la vue:

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

Pour ceux qui utilisent Django 1.7+

from Django.http import JsonResponse

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

document officiel

14
Andres

Vous voudrez utiliser le sérialiseur Django pour vous aider avec les commandes Unicode:

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

Avec Django _ Des vues basées sur des classes, vous pouvez écrire:

from Django.views import View
from Django.http import JsonResponse

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

et avec Django-Rest-Framework, vous pouvez écrire:

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

C'est très pratique avec Django version 1.7 ou supérieure car vous avez la classe JsonResponse, qui est une sous-classe de HttpResponse.

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

Pour les anciennes versions de Django, vous devez utiliser un objet HttpResponse.

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

Comment utiliser Google App Engine avec ajax (json)?

Code Javascript avec 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

Ceci est ma version préférée utilisant une vue basée sur les classes. Il vous suffit de sous-classer la vue de base et de remplacer la méthode get ().

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

Code Django views.py:

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

Code HTML 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

D'abord importer ceci:

from Django.http import HttpResponse

Si vous avez déjà le JSON:

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

Si vous obtenez le JSON à partir d'une autre requête HTTP:

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

Dans View, utilisez ceci:

form.field.errors|striptags

pour obtenir des messages de validation sans HTML

0
Deepak Sharma