I'm trying to convert a server side Ajax response script into a Django HttpResponse, but apparently it's not working.
This is the server-side script:
/* 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. } } } And this is the converted 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)) I'm using simplejson to encode the Python list (so it will return a JSON array). I couldn't figure out the problem yet. But I think that I did something wrong about the 'echo'.
117 Answers
I usually use a dictionary, not a list to return JSON content.
import json from django.http import HttpResponse response_data = {} response_data['result'] = 'error' response_data['message'] = 'Some error message' Pre-Django 1.7 you'd return it like this:
return HttpResponse(json.dumps(response_data), content_type="application/json") For Django 1.7+, use JsonResponse as shown in this SO answer like so :
from django.http import JsonResponse return JsonResponse({'foo':'bar'}) New in django 1.7
you could use JsonResponse objects.
from the docs:
from django.http import JsonResponse return JsonResponse({'foo':'bar'}) I use this, it works fine.
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 objects have been added to the Django framework itself which makes this task even easier:
from django.http import JsonResponse def some_view(request): return JsonResponse({"key": "value"}) Since Django 1.7 you have a standard JsonResponse that's exactly what you need:
from django.http import JsonResponse ... return JsonResponse(array_to_js, safe=False) You don't even need to json.dump your array.
0For those who use Django 1.7+
from django.http import JsonResponse def your_view(request): json_object = {'key': "value"} return JsonResponse(json_object) 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) And in the view:
resp_data = {'my_key': 'my value',} return JsonResponse(resp_data) With Django Class-based views you can write:
from django.views import View from django.http import JsonResponse class JsonView(View): def get(self, request): return JsonResponse({'some': 'data'}) and with Django-Rest-Framework you can write:
from rest_framework.views import APIView from rest_framework.response import Response class JsonView(APIView): def get(self, request): return Response({'some': 'data'}) You'll want to use the django serializer to help with unicode stuff:
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") Its very convenient with Django version 1.7 or higher as you have the JsonResponse class, which is a subclass of HttpResponse.
from django.http import JsonResponse def profile(request): data = { 'name': 'Raghav', 'location': 'India', 'is_active': False, 'count': 28 } return JsonResponse(data) For older versions of Django, you must use an HttpResponse object.
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') How to use google app engine with ajax (json)?
Code Javascript with 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) First import this:
from django.http import HttpResponse If you have the JSON already:
def your_method(request): your_json = [{'key1': value, 'key2': value}] return HttpResponse(your_json, 'application/json') If you get the JSON from another HTTP request:
def your_method(request): response = request.get(') return HttpResponse(response, '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=""></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> <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> This is my preferred version using a class based view. Simply subclass the basic View and override the get()-method.
import json class MyJsonView(View): def get(self, *args, **kwargs): resp = {'my_key': 'my value',} return HttpResponse(json.dumps(resp), mimetype="application/json" ) Most of these answers are out of date. JsonResponse is not recommended because it escapes the characters, which is usually undesired. Here's what I use:
views.py (returns HTML)
from django.shortcuts import render from django.core import serializers def your_view(request): data = serializers.serialize('json', YourModel.objects.all()) context = {"data":data} return render(request, "your_view.html", context) views.py (returns JSON)
from django.core import serializers from django.http import HttpResponse def your_view(request): data = serializers.serialize('json', YourModel.objects.all()) return HttpResponse(data, content_type='application/json') Bonus for Vue Users
If you want to bring your Django Queryset into Vue, you can do the following.
template.html
<div> {{ data }} </div> <script> let dataParsed = JSON.parse(document.getElementById('dataJson').textContent); var app = new Vue({ el: '#app', data: { yourVariable: dataParsed, }, }) </script> In View use this:
form.field.errors|striptags for getting validation messages without html
def your_view(request): response = {'key': "value"} return JsonResponse(json.dumps(response), content_type="application/json",safe=False) #Specify the content_type and use json.dump() son as the content not to be sent as object
1This way the json contents can be downloaded as a file with a specific filename.
import json from django.http import HttpResponse def download_json(request): data = {'some': 'information'} # serialize data obj as a JSON stream data = json.dumps(data) response = HttpResponse(data, content_type='application/json charset=utf-8') # add filename to response response['Content-Disposition'] = 'attachment; filename="filename.json"' return response 
