Creando una respuesta JSON usando Django y Python

Question

Estoy tratando de convertir una secuencia de comandos de respuesta Ajax del lado del servidor en una Django HttpResponse, pero aparentemente no está funcionando.

Este es el script del lado del servidor:

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

Y este es el código convertido

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

estoy usando simplejson para codificar la lista de Python (por lo que devolverá una matriz JSON) No pude resolver el problema todavía. Pero creo que hice algo mal con el 'eco'.

Answer 1

Normalmente uso un diccionario, no una lista para devolver el contenido de JSON.

import json 

from django.http import HttpResponse 

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

Pre-Django 1.7 que le devuelva la siguiente manera:

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

Para Django 1.7+, utilice JsonResponse como se muestra en this SO answer así:

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

Answer 2

utilizo este , funciona 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') 

Alternativa:

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

En Django 1.7 JsonResponse objetos se han añadido con el propio Marco Django lo que hace aún más esta tarea:

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

Answer 3

usted querrá utilizar el serializador django para ayudar con cosas 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") 

Answer 4

How to use google app engine with ajax (json)?

Código Javascript con jQuery:

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

Código 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) 

Answer 5

Ésta es mi versión preferida utilizando un punto de vista basado clase. Simplemente subclase la Vista básica y anule el método get().

import json 

class MyJsonView(View): 

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

Answer 6

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) 

Y en la vista:

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

Answer 7

nuevo en Django 1.7

usted podría utilizar JsonResponse objetos.

a partir de los documentos:

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

Answer 8

Desde Django 1.7 tiene una pantalla estándar JsonResponse eso es exactamente lo que necesita:

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

Ni siquiera necesita json.dump su matriz.

Answer 9

Django code(views.py): 


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

código 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> 

Answer 10

Para aquellos que utilizan Django 1.7+

from django.http import JsonResponse 

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

official docs

Answer 11

En Vista utilizar este:

form.field.errors|striptags 

para obtener mensajes de validación sin html

Answer 12

Es muy conveniente con Django versión 1.7 o superior y cuando tenga la clase JsonResponse, que es una subclase de HttpResponse.

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

Para las versiones anteriores de Django, debe utilizar un objeto 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') 

Answer 13

Con vistas basadas en la clase de Django puede escribir:

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

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

y con Django-Resto-marco se puede escribir:

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

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