serialized - python return json
Creando una respuesta JSON usando Django y Python (13)
Código de Django 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>
Estoy intentando convertir un script de respuesta Ajax del lado del servidor en un Django HttpResponse, pero aparentemente no funciona.
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''.
Con las vistas basadas en Django Class 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-Rest-Framework puedes escribir:
from rest_framework.views import APIView
from rest_framework.response import Response
class JsonView(APIView):
def get(self, request):
return Response({''some'': ''data''})
Desde Django 1.7 tienes un JsonResponse estándar que es exactamente lo que necesitas:
from django.http import JsonResponse
...
return JsonResponse(array_to_js, safe=False)
Ni siquiera necesitas json.dump tu matriz.
En vista usa esto:
form.field.errors|striptags
para obtener mensajes de validación sin html
Es muy conveniente con la versión 1.7 o superior de Django ya que tiene 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 versiones anteriores de Django, debes usar 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'')
Esta es mi versión preferida usando una vista basada en clase. Simplemente haga una subclase de 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" )
Nuevo en django 1.7
Podrías usar objetos JsonResponse .
de los documentos:
from django.http import JsonResponse
return JsonResponse({''foo'':''bar''})
Para aquellos que usan Django 1.7+
from django.http import JsonResponse
def your_view(request):
json_object = {''key'': "value"}
return JsonResponse(json_object)
Querrá usar el serializador django para ayudar con cosas de 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")
Usualmente uso un diccionario, no una lista para devolver contenido JSON.
import json
from django.http import HttpResponse
response_data = {}
response_data[''result''] = ''error''
response_data[''message''] = ''Some error message''
Pre-Django 1.7 lo devolverías así:
return HttpResponse(json.dumps(response_data), content_type="application/json")
Para Django 1.7+, use JsonResponse como se muestra en esta respuesta SO así:
from django.http import JsonResponse
return JsonResponse({''foo'':''bar''})
Yo uso esto, 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, los objetos JsonResponse se agregaron al propio marco de Django, lo que facilita aún más esta tarea:
from django.http import JsonResponse
def some_view(request):
return JsonResponse({"key": "value"})
¿Cómo usar el motor de aplicaciones de google con 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)
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)