Django

Question

में AJAX अनुरोध के लिए लौटने वाली फॉर्म त्रुटियों को मैं Django और jQuery के आसपास अपना रास्ता ढूंढ रहा हूं। मैंने Django में एक मूल रूप बनाया है। सबमिट करने पर क्लिक करने पर, मैं अपने डेटा को पोस्ट करने के लिए अलग से AJAX अनुरोध करने के लिए jQuery का उपयोग कर रहा हूं। यह बिट ठीक काम करता प्रतीत होता है और मैंने डेटा को सहेजने में कामयाब रहा है। जब कोई फॉर्म अमान्य होता है तो Django एक प्रमाणीकरण त्रुटि देता है। क्या कोई मुझे बता सकता है कि त्रुटि संदेशों के इस सेट को मेरे AJAX अनुरोध के जवाब के रूप में कैसे वापस किया जाए ताकि मैं आसानी से जेएस का उपयोग कर इसे फिर से चला सकूं और जो कुछ भी कर सकूं?

मुझे this स्निपेट मिला। जेएस बिट (प्रक्रिया जेसन) को देखते हुए आप देखेंगे कि उन्हें प्रतिक्रिया एचटीएमएल से निकालने से त्रुटि संदेश मिलते हैं। ऐसा लगता है कि मुझे थोड़ी सी झुकाव है। क्या यह इसके बारे में जाने का सबसे अच्छा तरीका है?

किसी भी अस्पष्टता के लिए मेरी माफ़ी।

अग्रिम धन्यवाद।

Answer 1

वाह, यह एक साल हो गया है क्योंकि मैंने यह धागा देखा है। खैर, Django 1.3 और जादुई, अनियंत्रित वर्ग-आधारित विचारों के आगमन के साथ, यह Django की दृश्य संबंधी कार्यक्षमता को सीमित करने के लिए और अधिक आसान हो गया है। मेरी परियोजना जो Django के क्लास-आधारित जेनेरिक सीआरयूएस दृश्यों का भारी उपयोग करता है उसे AJAX और JSON कार्यक्षमता की आवश्यकता होती है। मैंने AJAX का समर्थन करने और JSON प्रारूप में AJAX प्रतिक्रियाओं को वापस करने के लिए Django के अद्यतन दृश्य को संशोधित करने का एक उदाहरण जोड़ा है। एक नज़र:

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 
      ) 

प्रतिक्रिया JSON तीन क्षेत्रों में शामिल है - (success (जो एक मानव पठनीय संदेश है) message, data (जो इस मामले है प्रपत्र त्रुटियों की सूची होगा) और जो या तो true या false, यह दर्शाता है कि अनुरोध सफल था या नहीं।)। JQuery क्लाइंट-साइड में इसे संभालना बहुत आसान है। एक नमूना प्रतिक्रिया लगता है:

Content-Type: application/json 

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

यह सिर्फ मैं कैसे JSON करने के लिए प्रपत्र त्रुटियों धारावाहिक और एक वर्ग आधारित सामान्य दृश्य में इसे लागू किया लेकिन नियमित रूप से शैली विचारों के साथ काम करने के लिए के रूप में अच्छी cannibalized किया जा सकता का एक उदाहरण है।

Answer 2

जब मैं फ्रंट-एंड सत्यापन का उपयोग करता हूं, आमतौर पर प्रतिक्रिया में भाग होते हैं जिन्हें आप डॉट नोटेशन (dataReturned.specificData) के माध्यम से एक्सेस कर सकते हैं।

इस बात पर आधारित है कि आप डेटा को वापस कैसे और कैसे कर रहे हैं, इसका उपयोग करने के लिए महत्वपूर्ण है। जितना अधिक मॉड्यूलर आप डेटा को वापस संभालते हैं, उतना ही आसान है।

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

Answer 3

आप मेरे लिए इसे संभालने के लिए मेरे एडीएक्स लाइब्रेरी का उपयोग कर सकते हैं। , अपने रास्ते पर कहीं एप्लिकेशन इंस्टॉल करें adjax.js फ़ाइल लिंक और आपके विचार के लिए निम्न जोड़ने जोड़ें:

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

adjax.js फ़ाइल लोड करने के बाद जावास्क्रिप्ट का उपयोग कर प्रपत्र सक्षम करें:

$('form').adjaxify(); 

और आनंद लें: -)

यहां और अधिक विशेषताएं: http://adjax.hardysoftware.com.au/how/। मैं अगले सप्ताह में एक "1.0" संस्करण जारी कर दूंगा, मुझे बताएं कि चीजें कैसे जाती हैं। Google कोड प्रोजेक्ट यहां है: http://code.google.com/p/django-adjax/

Answer 4

यह प्रश्न पुराना है, लेकिन मुझे लगता है कि सबसे छोटा जवाब इस तरह के दृश्य में सरल जेसन का उपयोग कर सकता है।

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) 

अब आप ऊपर वर्णित कैल्विन जैसे अपने jquery में डेटा तक पहुंच सकते हैं। jQuery, यह डेटा को संभालने के लिए आसान बना देता है आप कुछ इस तरह कर सकता है:

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

Answer 5

मैं जानता हूँ कि यह एक पुराना है और सवाल का जवाब! अभी भी योगदान देना चाहते हैं। जिस समाधान को मैं सबसे ज्यादा पसंद करता हूं वह उन तरीकों के लिए सजावट का उपयोग करना है जो जेसन को त्रुटि देनी चाहिए।

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

डेकोरेटर किसी भी ध्यान में न आया अपवाद और आउटपुट त्रुटि की जानकारी और ढेर के साथ एक json पकड़ेगा:

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 

तो फिर आप अपने Django विधि परिभाषित करते हैं।

मुझे व्यक्तिगत रूप से यह एक डीजेंगो सर्वर के लिए एक बहुत अच्छा समाधान मिल जाता है जो एचटीएमएल और जेसन प्रतिक्रियाओं को मिश्रित करता है।