Vraag Formulierfouten retourneren voor AJAX-aanvraag in Django


Ik heb de weg gevonden in Django en jQuery. Ik heb een basisvorm in Django gebouwd. Nadat ik op submit heb geklikt, gebruik ik jQuery om een ​​AJAX-verzoek aan de sever te doen om mijn gegevens te plaatsen. Dit bit lijkt goed te werken en ik heb de gegevens kunnen opslaan. Django retourneert een ValidationError wanneer een formulier ongeldig is. Kan iemand me vertellen hoe ik deze reeks foutmeldingen moet retourneren als reactie op mijn AJAX-verzoek, zodat ik het gemakkelijk kan herhalen via JS en alles kan doen?

ik vond deze snippet. Als u naar het JS-bit (processJson) kijkt, ziet u dat hij de foutmeldingen lijkt te ontvangen door deze uit de antwoord-HTML te extraheren. Het lijkt me nogal kuvers. Is dit de beste manier om het aan te pakken?

Mijn excuses voor enige vaagheid.

Bij voorbaat bedankt.


15
2018-04-12 19:23


oorsprong


antwoorden:


Deze vraag is oud, maar ik denk dat het kortste antwoord misschien eenvoudige json is in een weergave als deze.

from django.utils import simplejson

def ajax(request):
    if request.method == 'POST':
        form = someForm(request.POST)
        if form.is_valid():
            form.save()
            return HttpResponse(something)
        else:
            errors = form.errors
            return HttpResponse(simplejson.dumps(errors))
    else:
        return HttpResponse(something)

nu hebt u toegang tot de gegevens in uw jQuery zoals Calvin hierboven beschreven. JQuery maakt het gemakkelijk om met de gegevens om te gaan. Je zou zoiets als dit kunnen doen:

var errors = jQuery.parseJSON(data)
    alert(errors.username)

11
2018-03-21 22:18



Wow, het is een jaar geleden dat ik deze draad heb gezien. Welnu, met de komst van Django 1.3 en de magische, ongedocumenteerde, op klassen gebaseerde meningen, is het eenvoudiger geworden de kijkgerelateerde functionaliteit van Django te verruimen. Mijn project dat veelvuldig gebruik maakt van de op klassen gebaseerde generieke CRUS-views van Django, heeft AJAX- en JSON-functionaliteit nodig. Ik heb een voorbeeld toegevoegd van hoe ik de updateweergave van Django heb aangepast om AJAX te ondersteunen en AJAX-antwoorden in de JSON-indeling te retourneren. Even kijken:

def errors_to_json(errors):
    """
    Convert a Form error list to JSON::
    """
    return dict(
            (k, map(unicode, v))
            for (k,v) in errors.iteritems()
        )

class HybridUpdateView(UpdateView):
    """
    Custom update generic view that speaks JSON
    """
    def form_valid(self, form, *args, **kwargs):
        """
        The Form is valid
        """
        form.save()

        self.message = _("Validation passed. Form Saved.")
        self.data = None
        self.success = True

        payload = {'success': self.success, 'message': self.message, 'data':self.data}

        if self.request.is_ajax():
            return HttpResponse(json.dumps(payload),
                content_type='application/json',
            )
        else:
            return super(HybridUpdateView, self).form_valid(
                form, *args, **kwargs
            )

    def form_invalid(self, form, *args, **kwargs):
        """
        The Form is invalid
        """
        #form.save()

        self.message = _("Validation failed.")
        self.data = errors_to_json(form.errors)
        self.success = False

        payload = {'success': self.success, 'message': self.message, 'data':self.data}

        if self.request.is_ajax():
            return HttpResponse(json.dumps(payload),
                content_type='application/json',
            )
        else:
            return super(HybridUpdateView, self).form_invalid(
                form, *args, **kwargs
            )

Het antwoord JSON bevat drie velden - message (dat is een voor mensen leesbaar bericht), data (dit is in dit geval de lijst met formulierfouten) en success (wat ook is true of false, aangevende of de aanvraag succesvol was of niet.). Dit is heel gemakkelijk te verwerken in jQuery-client. Een voorbeeldreactie ziet er als volgt uit:

Content-Type: application/json

{"message": "Validation failed.", "data": {"host": ["This field is required."]}, "success": false}

Dit is slechts een voorbeeld van hoe ik de vormfouten heb geserialiseerd naar JSON en geïmplementeerd in een op klassen gebaseerde generieke weergave, maar kan ook worden gekannibaliseerd om te werken met standaard stijloverzichten.


4
2017-09-28 19:04



Wanneer ik front-end validatie gebruik, bevat het antwoord meestal chunks die toegankelijk zijn via puntnotatie (dataReturned.specificData).

Op basis van wat en hoe u gegevens retourneert, is de sleutel tot hoe u er toegang tot krijgt. Hoe modulairer u omgaat met de geretourneerde gegevens, hoe gemakkelijker u toegang krijgt.

// Start ajax request to server
$.ajax({
    url: '/path_to_service',
    type: 'POST',
    data: { key: value },

    // Do something with the data
    success: function(data) {
        // Data is everything that is returned from the post
        alert(data);
        // data.message could be a piece of the entire return
        alert(data.message);
    } error: function(data) { // Handle fatal errors }
});

1
2018-04-12 19:38



U kunt mijn adjax-bibliotheek gebruiken om dit voor u te regelen. Installeer de app ergens op uw pad, koppel de adjax.js bestand en voeg het volgende toe aan uw weergave:

import adjax
@adjax.adjax_response
def my_view(request):
    # prepare my_form with posted data as normal
    adjax.form(request, my_form)

Schakel het formulier in met javascript na het laden van de adjax.js het dossier:

 $('form').adjaxify();

En geniet :-)

Meer functies hier: http://adjax.hardysoftware.com.au/how/ . Ik zal de volgende week een "1.0" -versie uitbrengen, laat me weten hoe het gaat. Google-codeproject is hier: http://code.google.com/p/django-adjax/


0
2018-04-13 12:27



Ik weet dat dit een oude en beantwoorde vraag is! Wil nog steeds een steentje bijdragen. De oplossing die ik het leukst vind, is om een ​​decorateur te gebruiken voor methoden die fouten zouden moeten veroorzaken.

import traceback,sys,simplejson

def unhandled(e):
  """
     Helper function to format an exception and it's stack
  """
  exc_type, exc_value, exc_traceback = sys.exc_info()
  lines = traceback.format_exception(exc_type, exc_value, exc_traceback)
  stack =  ''.join(line for line in lines)
  return HttpResponse(simplejson.dumps({"error":-1, "response": e.message ,"stack":stack}), content_type='application/json')


def use_json_except(f):
  def new_f(*args):
    try:
      return f(*args)
    except Exception as e:
      return unhandled(e)
    return new_f

Vervolgens definieer je je Django-methode:

 @use_json_except
 def add_annotation(request):
     ....

De decorateur zal alle niet-afgevangen uitzonderingen opvangen en een json uitvoeren met de foutinformatie en de stapel.

Ik vind dit persoonlijk een zeer goede oplossing voor een django-server die html- en json-antwoorden combineert.


0
2018-04-17 16:59