Estoy tratando de procesar las JSON/peticiones Ajax con Django/Python.

solicitud.is_ajax() es True en la solicitud, pero no tengo idea de donde la carga es con los datos JSON.

request.POST.dir contiene esto:

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

Hay, aparentemente, ninguna de las teclas en la petición post teclas.

Cuando miro el POST en Firebug, hay datos JSON ser enviado en la petición.

  • Lo que realmente se Publicar? Nos muestran la llamada de javascript.
  • Y len(request.POST) y request.POST.items() también sería de ayuda.
InformationsquelleAutor | 2009-07-30

12 Comentarios

  1. 219

    Si vas a publicar JSON a Django, creo que quiere que request.body (request.raw_post_data en Django < 1.4). Esto le dará la cruda JSON datos enviados a través de correos. Desde allí se puede procesar más.

    Aquí hay un ejemplo usando JavaScript, jQuery, jquery-json y 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")
    • Por favor explique qué entiende usted por ‘el cliente de prueba’? ¿Qué estás tratando de hacer?
    • No estoy tratando de ser grosero: Por la prueba del «cliente», me refiero a la de django «cliente de prueba.» ¿Cómo se prueba vistas si no es con el cliente de prueba?
    • Tomar en cuenta: Usted debe terminar url con la barra diagonal ( / ) char. También deshabilitar CSRF con @csrf_exempt
    • NOTA: si usted está usando 1.4 esto se llama solicitud.cuerpo . raw_post_data está en desuso…
    • para probar con django unittest acaba de hacer self.client.post('/event/save-json/', json.dumps(python_dict), HTTP_X_REQUESTED_WITH='XMLHttpRequest', content_type="application/json")
    • Tenga en cuenta que este código de Django siempre devuelve una respuesta 200, incluso cuando el método de solicitud que está mal. No me refiero a ser un smartarse, pero veo que los ingenieros de hacerlo en la vida real código todo el tiempo, y hace front-end más difícil. En este caso, return HttpResponseBadRequest() y return HttpResponseNotAllowed(['POST']) son apropiados else cláusulas.

  2. 61

    Yo tenía el mismo problema. Yo había sido la publicación de un complejo de respuesta en JSON, y yo no podía leer mis datos con la solicitud.POST diccionario.

    Mi JSON POSTERIOR de los datos fue:

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

    En este caso, usted necesita para utilizar el método proporcionado por aurealus. Leer la solicitud.cuerpo y deserializar con el 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")
    • Estoy teniendo problemas con la línea 4: json_data = simplejson.loads(request.raw_post_data) ¿estás seguro de que correctamente establecido?
    • Estoy bastante seguro de que la solicitud.raw_post_data es la forma correcta como lo hice yo uso este ejemplo en las pruebas. ¿Qué tipo de problemas tienes @weezybizzle?
    • Los datos que llegan un poco más de texto que se anexa demasiado lo que estaba arruinando el análisis. Así fue que el 100% de mí.
    • eso es perfecto! Gracias!
    • django.utils.simplejson ha sido eliminado en las versiones recientes. Sólo el uso de la stdlib json de la biblioteca.
    • Usted querrá usar solicitud.cuerpo en lugar de la solicitud.raw_post_data para Django 1.4+

  3. 33

    Método 1

    Cliente : Enviar como 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}

    Servidor :

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

    Método 2

    Cliente : Enviar como x-www-form-urlencoded

    (Nota: contentType & processData han cambiado, JSON.stringify no es necesario)

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

    Servidor :

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

    Cambiado en 1.5+ : https://docs.djangoproject.com/en/dev/releases/1.5/#non-form-data-in-http-requests

    No-formulario de datos en las solicitudes HTTP
    :
    solicitud.POST no incluirá los datos publicados a través de peticiones HTTP con
    no forma específica de contenidos de tipo en el encabezado. En versiones anteriores, los datos de
    publicado con el contenido-tipos distintos de multipart/form-data o
    application/x-www-form-urlencoded sería todavía representada en
    la solicitud.POST atributo. Los desarrolladores que deseen acceder a la cruda POST
    los datos para estos casos, debe utilizar la solicitud.atributo cuerpo en su lugar.

    Probablemente relacionados con la

    • Re 1 – django.http.request.RawPostDataException: You cannot access body after reading from request's data stream
  4. 17

    Su importante recordar Python 3 tiene una forma diferente de representar las cadenas – que son matrices de bytes.

    Utilizando Django 1.9 y Python 2.7 y el envío de los datos JSON en el cuerpo principal (no un encabezado) que usaría algo como:

    mydata = json.loads(request.body)

    Pero para Django 1.9 y Python 3.4 se debería utilizar:

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

    Acabo de ir a través de esta curva de aprendizaje haciendo mi primer Py3 aplicación de Django!

    • Gracias por tu explicación! Estoy usando Django 1.10 y Python 3.5, mydata = json.cargas de solicitud.cuerpo.decode(«utf-8»)) funciona!
  5. 9

    sobre django 1.6 python 3.3

    cliente

    $.ajax({
        url: '/urll/',
        type: 'POST',
        contentType: 'application/json; charset=utf-8',
        data: JSON.stringify(json_object),
        dataType: 'json',
        success: function(result) {
            alert(result.Result);
        }
    });

    servidor

    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")))
  6. 5

    HTTP POST carga es de sólo un piso montón de bytes. Django (como la mayoría de los marcos) descodifica en un diccionario de cualquiera de las URL de los parámetros codificados, o MIME de varias partes de la codificación. Si usted acaba de volcar los datos en JSON en el contenido de la entrada, Django no decodificar. Hacer la decodificación JSON desde el POST completo de contenido (no el diccionario); o poner los datos JSON en una MIME multipart contenedor.

    En definitiva, mostrar el código JavaScript. El problema parece estar allí.

    • Yo veo el problema ahora! El tipo=’json’ parámetro en jquery se refiere a qué tipo de esperar, no lo envía. Es el envío de forma regular publicar datos codificados, así que si quiero enviar «json» necesito alguna manera de convertirlo en una cadena, y de paso «json={foo:bar, }», etc no me lo puedo creer, sin embargo, que como la mayoría de las personas lo hacen. Debo estar perdiendo algo aquí.
    • En realidad, usted puede convertir la forma de una cadena JSON en jQuery con el .función serialize (). Pero, ¿por qué necesita enviar json, aunque? Lo que está mal con sólo enviar los datos del formulario?
    • Hay muchos casos donde la forma cruda de datos no es suficiente; JSON permite enviar jerárquica de los objetos, no sólo de la clave : los pares de valores. Usted puede enviar conjuntos anidados, matrices, etc. Usted probablemente podría hacer todo eso con el post de datos, pero no es tan conveniente. Es algo bueno siempre tratar con JSON, hacia y desde
  7. 5

    request.raw_post_data ha quedado obsoleta. Uso request.body lugar

    • Gracias por esto! Funcionó a la perfección.
  8. 4

    Algo como esto. Ha funcionado:
    Datos de la solicitud de cliente

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

    Proceso de solicitud en el servidor

    @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")
  9. 2
    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))
  10. -2

    Usando Angular debe agregar encabezado de solicitud o añadir el módulo de configuración
    encabezados: {'Content-Type': 'application/x-www-form-urlencoded'}

    $http({
        url: url,
        method: method,
        timeout: timeout,
        data: data,
        headers: {'Content-Type': 'application/x-www-form-urlencoded'}
    })
  11. -4

    solicitud.POST es sólo un diccionario como objeto, por lo que sólo índice en ella con dict sintaxis.

    Suponiendo que el campo de formulario es fred, se podría hacer algo como esto:

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

    Alternativamente, el uso de un objeto de formulario para tratar con los datos de envío.

    • Yo estaba buscando en la solicitud.POST[‘json’] que no contenía nada. len era 0
    • Entonces definitivamente ayudará a ver a su llamada de JavaScript, como Daniel sugirió.
    • bonita y sencilla. Gracias
    • solicitud.POST sólo se llena cuando el cuerpo de la petición POST se Forma codificada, de otra forma, es vacío.

Dejar respuesta

Please enter your comment!
Please enter your name here