Où sont mes données JSON dans ma requête Django entrante?

J'essaie de traiter les demandes JSON / Ajax entrantes avec Django / Python.

request.is_ajax()est Truesur la demande, mais je n'ai aucune idée de l'emplacement de la charge utile avec les données JSON.

request.POST.dir contient ceci:

['__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']

Il n'y a apparemment aucune clé dans les clés de message de demande.

Lorsque je regarde le POST dans Firebug , des données JSON sont envoyées dans la demande.

Si vous publiez du JSON sur Django, je pense que vous le souhaitez request.body( request.raw_post_datasur Django <1.4). Cela vous donnera les données JSON brutes envoyées via la poste. De là, vous pouvez le traiter davantage.

Voici un exemple utilisant JavaScript, jQuery , jquery-json et 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")

J'ai eu le même problème. J'avais publié une réponse JSON complexe et je ne pouvais pas lire mes données à l'aide du dictionnaire request.POST.

Mes données JSON POST étaient:

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

Dans ce cas, vous devez utiliser la méthode fournie par aurealus. Lisez le request.body et désérialisez-le avec le 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")

Méthode 1

Client: envoyer en tant que 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}

Serveur:

data = json.loads(request.body) # {'name':'John', 'age': 42}

Méthode 2

Client: Envoyer en tant que x-www-form-urlencoded
(Remarque: contentType& processDataont changé, JSON.stringifyn'est pas nécessaire)

$.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

Serveur:

data = request.POST # will be <QueryDict: {u'name':u'John', u'age': 42}>

Modifié dans la version 1.5+: https://docs.djangoproject.com/en/dev/releases/1.5/#non-form-data-in-http-requests

Données non formelles dans les requêtes HTTP :
request.POST n'inclura plus les données publiées via des requêtes HTTP avec des types de contenu non spécifiques au formulaire dans l'en-tête. Dans les versions précédentes, les données publiées avec des types de contenu autres que multipart / form-data ou application / x-www-form-urlencoded finiraient toujours par être représentées dans l'attribut request.POST. Les développeurs souhaitant accéder aux données POST brutes pour ces cas doivent utiliser à la place l'attribut request.body.

Probablement lié

• https://groups.google.com/forum/#!msg/django-developers/s8OZ9yNh-8c/yWeY138TpFEJ
• https://code.djangoproject.com/ticket/17942 . Fixé dans 1.7
• http://homakov.blogspot.in/2012/06/x-www-form-urlencoded-vs-json-pros-and.html

Il est important de se rappeler que Python 3 a une manière différente de représenter les chaînes - ce sont des tableaux d'octets.

En utilisant Django 1.9 et Python 2.7 et en envoyant les données JSON dans le corps principal (pas un en-tête), vous utiliseriez quelque chose comme:

mydata = json.loads(request.body)

Mais pour Django 1.9 et Python 3.4, vous utiliseriez:

mydata = json.loads(request.body.decode("utf-8"))

Je viens de passer par cette courbe d'apprentissage en créant ma première application Py3 Django!

request.raw_responseest désormais obsolète. Utilisationrequest.body plutôt pour traiter des données de formulaire non conventionnelles telles que des charges utiles XML, des images binaires, etc.

Documentation Django sur le problème .

sur 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);
    }
});

serveur

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

La charge utile HTTP POST est juste un ensemble plat d'octets. Django (comme la plupart des frameworks) le décode dans un dictionnaire à partir de paramètres encodés en URL ou d'un encodage MIME-multipart. Si vous videz simplement les données JSON dans le contenu POST, Django ne les décodera pas. Soit faites le décodage JSON à partir du contenu POST complet (pas du dictionnaire); ou placez les données JSON dans un wrapper MIME en plusieurs parties.

En bref, montrez le code JavaScript. Le problème semble être là.

request.raw_post_dataest obsolète. Utilisez request.bodyplutôt

Quelque chose comme ça. Cela a fonctionné: demander des données au 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);
});

Traiter la demande sur le serveur

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

En utilisant Angular, vous devez ajouter un en-tête à la demande ou l'ajouter aux en-têtes de configuration du module: {'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 est juste un objet de type dictionnaire, il suffit donc de l'indexer avec la syntaxe dict.

En supposant que votre champ de formulaire est fred, vous pouvez faire quelque chose comme ceci:

if 'fred' in request.POST:
    mydata = request.POST['fred']

Vous pouvez également utiliser un objet de formulaire pour traiter les données POST.