Wo sind meine JSON-Daten in meiner eingehenden Django Anfrage?
-
05-07-2019 - |
Frage
Ich versuche, eingehenden JSON / Ajax-Anfragen mit Django / Python zu verarbeiten.
request.is_ajax()
ist True
auf Wunsch, aber ich habe keine Ahnung, wo die Nutzlast mit den JSON-Daten ist.
request.POST.dir
enthält diese:
['__class__', '__cmp__', '__contains__', '__copy__', '__deepcopy__', '__delattr__',
'__delitem__', '__dict__', '__doc__', '__eq__', '__ge__', '__getattribute__',
'__getitem__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__',
'__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__',
'__setattr__', '__setitem__', '__str__', '__weakref__', '_assert_mutable', '_encoding',
'_get_encoding', '_mutable', '_set_encoding', 'appendlist', 'clear', 'copy', 'encoding',
'fromkeys', 'get', 'getlist', 'has_key', 'items', 'iteritems', 'iterkeys', 'itervalues',
'keys', 'lists', 'pop', 'popitem', 'setdefault', 'setlist', 'setlistdefault', 'update',
'urlencode', 'values']
Es gibt offenbar keine Schlüssel in der Anforderungspost Tasten.
Wenn ich auf der POST schauen in Firebug gibt es JSON-Daten in die geschickt werden Anfrage.
Lösung
Wenn Sie JSON Django Mitteilung verfassen, ich glaube, Sie wollen request.body
(request.raw_post_data
auf Django <1.4). Dies gibt Ihnen die rohen JSON-Daten über die Post zugestellt. Von dort können Sie es weiter verarbeiten.
Hier ist ein Beispiel unter Verwendung von JavaScript, jQuery , jquery-json und Django.
JavaScript:
var myEvent = {id: calEvent.id, start: calEvent.start, end: calEvent.end,
allDay: calEvent.allDay };
$.ajax({
url: '/event/save-json/',
type: 'POST',
contentType: 'application/json; charset=utf-8',
data: $.toJSON(myEvent),
dataType: 'text',
success: function(result) {
alert(result.Result);
}
});
Django:
def save_events_json(request):
if request.is_ajax():
if request.method == 'POST':
print 'Raw Data: "%s"' % request.body
return HttpResponse("OK")
Django <1.4:
def save_events_json(request):
if request.is_ajax():
if request.method == 'POST':
print 'Raw Data: "%s"' % request.raw_post_data
return HttpResponse("OK")
Andere Tipps
Ich hatte das gleiche Problem. Ich hatte eine komplexe JSON-Antwort wurde Posting, und ich konnte meine Daten mit Hilfe des request.POST Wörterbuch nicht lesen.
Meine JSON POST-Daten waren:
//JavaScript code:
//Requires json2.js and jQuery.
var response = {data:[{"a":1, "b":2},{"a":2, "b":2}]}
json_response = JSON.stringify(response); // proper serialization method, read
// http://ejohn.org/blog/ecmascript-5-strict-mode-json-and-more/
$.post('url',json_response);
In diesem Fall müssen Sie das Verfahren durch aurealus verwenden. Lesen Sie die request.body und deserialisieren es mit dem json stdlib.
#Django code:
import json
def save_data(request):
if request.method == 'POST':
json_data = json.loads(request.body) # request.raw_post_data w/ Django < 1.4
try:
data = json_data['data']
except KeyError:
HttpResponseServerError("Malformed data!")
HttpResponse("Got json data")
Methode 1
Client: Senden als JSON
$.ajax({
url: 'example.com/ajax/',
type: 'POST',
contentType: 'application/json; charset=utf-8',
processData: false,
data: JSON.stringify({'name':'John', 'age': 42}),
...
});
//Sent as a JSON object {'name':'John', 'age': 42}
Server:
data = json.loads(request.body) # {'name':'John', 'age': 42}
Methode 2
Auftraggeber: Jemand x-www-form-urlencoded
(Anmerkung: contentType
& processData
geändert haben, wird JSON.stringify
nicht erforderlich)
$.ajax({
url: 'example.com/ajax/',
type: 'POST',
data: {'name':'John', 'age': 42},
contentType: 'application/x-www-form-urlencoded; charset=utf-8', //Default
processData: true,
});
//Sent as a query string name=John&age=42
Server:
data = request.POST # will be <QueryDict: {u'name':u'John', u'age': 42}>
Changed in 1.5+: https://docs.djangoproject.com/en/dev/releases/1.5/#non-form-data-in-http-requests
Nicht-Formulardaten in HTTP-Anforderungen :
request.POST nicht mehr Daten über HTTP-Anfragen geschrieben ist mit nicht formularspezifischen Content-Typ in der Kopfzeile. In früheren Versionen, Daten geschrieben mit Content-Typ anders als multipart / form-data oder application / x-www-form-urlencoded noch vertreten würde am Ende in das request.POST Attribut. Entwickler, die die rohen POST zugreifen Daten für diese Fälle stattdessen das request.body Attribut verwendet werden sollen.
Wahrscheinlich im Zusammenhang
request.raw_response
ist veraltet. Verwenden Sie request.body
stattdessen nicht-konventionelle Formulardaten wie zB XML-Nutzlasten zu verarbeiten, binäre Bilder, etc.
Es ist wichtig, Python 3 hat eine andere Art und Weise zu erinnern Strings darzustellen -. Sie sind Byte-Arrays
Mit Django 1.9 und Python 2.7 und die JSON-Daten in dem Hauptkörper zu senden (keinen Header) Sie so etwas wie verwenden würden:
mydata = json.loads(request.body)
Aber für Django 1.9 und Python 3.4 würden Sie verwenden:
mydata = json.loads(request.body.decode("utf-8"))
Ich gehe gerade durch diese Lernkurve meiner erst PY3 Django app machen!
auf django 1.6 Python 3.3
Client
$.ajax({
url: '/urll/',
type: 'POST',
contentType: 'application/json; charset=utf-8',
data: JSON.stringify(json_object),
dataType: 'json',
success: function(result) {
alert(result.Result);
}
});
Server
def urll(request):
if request.is_ajax():
if request.method == 'POST':
print ('Raw Data:', request.body)
print ('type(request.body):', type(request.body)) # this type is bytes
print(json.loads(request.body.decode("utf-8")))
Die HTTP-POST-Nutzlast ist nur ein flaches Bündel von Bytes. Django (wie die meisten Rahmen) dekodiert sie in einem Wörterbuch von entweder URL codierten Parameter oder MIME-Multipart-Codierung. Wenn Sie nur die JSON-Daten in der POST-Inhalt-Dump, wird Django dekodieren es nicht. Entweder tun, um die JSON-Decodierung aus dem vollen POST Inhalt (nicht das Wörterbuch); oder setzen Sie die JSON-Daten in einen MIME-Multipart-Wrapper.
Kurz gesagt, zeigt den JavaScript-Code. Das Problem scheint es zu sein.
request.raw_post_data
ist veraltet. Verwenden request.body
statt
So etwas wie dies. Es wird gearbeitet: Anforderungsdaten von Client
registerData = {
{% for field in userFields%}
{{ field.name }}: {{ field.name }},
{% endfor %}
}
var request = $.ajax({
url: "{% url 'MainApp:rq-create-account-json' %}",
method: "POST",
async: false,
contentType: "application/json; charset=utf-8",
data: JSON.stringify(registerData),
dataType: "json"
});
request.done(function (msg) {
[alert(msg);]
alert(msg.name);
});
request.fail(function (jqXHR, status) {
alert(status);
});
Prozessanforderung auf dem Server
@csrf_exempt
def rq_create_account_json(request):
if request.is_ajax():
if request.method == 'POST':
json_data = json.loads(request.body)
print(json_data)
return JsonResponse(json_data)
return HttpResponse("Error")
html code
file name : 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>
<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>
Django code:
Inside views.py
def view(request):
if request.method == 'POST':
print request.body
data = request.body
return HttpResponse(json.dumps(data))
Angular benutzen, sollten Sie Header Anfrage hinzufügen oder fügen Sie es config-Modul
Header: {'Content-Type': 'application/x-www-form-urlencoded'}
$http({
url: url,
method: method,
timeout: timeout,
data: data,
headers: {'Content-Type': 'application/x-www-form-urlencoded'}
})
request.POST ist nur ein Wörterbuch-ähnliches Objekt, so dass nur Index in denen sie mit dict Syntax.
Angenommen, Ihr Formularfeld ist fred, Sie so etwas tun könnte:
if 'fred' in request.POST:
mydata = request.POST['fred']
Alternativ können Sie ein Formular-Objekt mit den POST-Daten behandeln.