Een JSON-antwoord maken met Django en Python

Ik probeer een server-side Ajax-antwoordscript om te zetten in een Django HttpResponse, maar blijkbaar werkt het niet.

Dit is het 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.
        }
    }
}

En dit is de geconverteerde 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))

Ik gebruik Simplejson om de Python-lijst te coderen (dus het zal een JSON-array retourneren). Ik kon het probleem nog niet achterhalen. Maar ik denk dat ik iets verkeerds heb gedaan over de ‘echo’.

Antwoord 1, Autoriteit 100%

Ik gebruik meestal een woordenboek, geen lijst om JSON-inhoud terug te zetten.

import json
from django.http import HttpResponse
response_data = {}
response_data['result'] = 'error'
response_data['message'] = 'Some error message'

Pre-django 1.7 U zou het zo retourneren:

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

Voor Django 1.7+, gebruik JsonResponsezoals weergegeven in dit dus antwoord zoals SO:

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

Antwoord 2, Autoriteit 18%

Nieuw in Django 1.7

U kunt JSONResponse objecten gebruiken.

Vanaf de documenten:

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

Antwoord 3, Autoriteit 14%

Ik gebruik dit, het werkt prima.

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

Alternatief:

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 zijn JsonResponse-objecten toegevoegd aan het Django-framework zelf, wat deze taak nog eenvoudiger maakt:

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

Antwoord 4, autoriteit 3%

Sinds Django 1.7 heb je een standaard JsonResponsedat is precies wat je nodig hebt:

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

Je hoeft je array niet eens te json.dumpen.

Antwoord 5, autoriteit 2%

Voor degenen die Django 1.7+ gebruiken

from django.http import JsonResponse
def your_view(request):
    json_object = {'key': "value"}
    return JsonResponse(json_object)

Officiële documenten

Antwoord 6, Autoriteit 2%

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)

en in de weergave:

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

Antwoord 7

Met Django Class-gebaseerde weergaven kunt u schrijven:

from django.views import View
from django.http import JsonResponse
class JsonView(View):
    def get(self, request):
        return JsonResponse({'some': 'data'})

En met Django-rest-framework kunt u schrijven:

from rest_framework.views import APIView
from rest_framework.response import Response
class JsonView(APIView):
    def get(self, request):
        return Response({'some': 'data'})

Antwoord 8

U wilt de Django Serializer gebruiken om te helpen met Unicode-dingen:

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

Antwoord 9

Het is erg handig met Django versie 1.7 of hoger omdat je de JsonResponse-klasse hebt, wat een subklasse is van HttpResponse.

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

Voor oudere versies van Django moet u een HttpResponse-object gebruiken.

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

Antwoord 10

Google-app-engine gebruiken met ajax (json) ?

Codeer Javascript met JQuery:

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

Python coderen

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)

Antwoord 11

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="https://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>

Antwoord 12

Importeer eerst dit:

from django.http import HttpResponse

Als je de JSON al hebt:

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

Als u de JSON van een ander HTTP-aanvraag krijgt:

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

Antwoord 13

Dit is mijn favoriete versie met behulp van een op klassen gebaseerde weergave.
Subclass de basisweergave en negeer de 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" )

Antwoord 14

Gebruik JSONResponse

from django.http import JsonResponse

Antwoord 15

Gebruik dit:

form.field.errors|striptags

Voor het verkrijgen van validatie-berichten zonder HTML

Antwoord 16

De meeste van deze antwoorden zijn verouderd. JsonResponse wordt niet aanbevolen omdat het aan de personages ontsnapt, die meestal ongewenst is. Dit is wat ik gebruik:

bekeken.py (retourneert 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)

bekeken.py (retourneert 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 voor Vue-gebruikers

Als je je Django Queryset naar Vue wilt brengen, kun je het volgende doen.

sjabloon.html

<div id="dataJson" style="display:none">
{{ data }}
</div>
<script>
let dataParsed = JSON.parse(document.getElementById('dataJson').textContent);
var app = new Vue({
  el: '#app',
  data: {
    yourVariable: dataParsed,
  },
})
</script>