रेल: ड्राय स्टाइल अजाक्स सत्यापन

समस्या का बयान

1. विशेषताओं को मान्य करते समय, एक तर्क का उपयोग करें: पीठ और सामने दोनों के लिए
2. जल्दी से अलग-अलग रूपों पर "लटका" चेक करें और लचीले ढंग से उन्हें कॉन्फ़िगर करें (तर्क और दृश्य दोनों)

उपकरण

चलिए मुद्दे पर आते हैं

• email - ईमेल पता
• frequency - वह आवृत्ति जिसके साथ मेलिंग इस पते पर जाएगी

• email आवश्यक है
• email अद्वितीय होना चाहिए
• email होना चाहिए (एक कुत्ते और अन्य चीजों के साथ)
• frequency वैकल्पिक है, लेकिन अगर वहाँ है, यह 1 से 7 सीमा में होना चाहिए

 class Email < ActiveRecord::Base before_save { self.email = email.downcase } VALID_EMAIL_REGEX = /\A[\w+\-.]+@[az\d\-.]+\.[az]+\z/i validates :email, presence: true, uniqueness: { case_sensitive: false }, format: { with: VALID_EMAIL_REGEX } validates_inclusion_of :frequency, in: 1..7, allow_blank: true end 

 class EmailsController < ApplicationController def new @email = Email.new end def create @email = Email.new(email_params) if @email.save flash[:success] = 'Email !' redirect_to emails_url else render :new end end private def email_params params.require(:email).permit(:email, :frequency) end end 

 %h1   = form_for @email do |f| = render partial: 'shared/error_messages', locals: { object: f.object } %p= f.text_field :email, placeholder: '' %p= f.text_field :frequency, placeholder: ' ' %p= f.submit '!' 

मैं प्लगइन के लिए प्रलेखन के लिंक को दोहराऊंगा ताकि यह अब वापस न आए। संरचित सामग्री के साथ एक छोटी सी समस्या है, लेकिन सभी जानकारी है।

 jQuery -> validate_url = '/emails/validate' $('#new_email, [id^=edit_email_]').validate( debug: true rules: 'email[email]': required: true remote: url: validate_url type: 'post' 'email[frequency]': remote: url: validate_url type: 'post' ) 

• validate_url = '/emails/validate'
  वह पता जिसे हम क्षेत्र मान की जाँच करने के लिए ajax अनुरोध भेजेंगे
• $('#new_email, [id^=edit_email_]').validate
  हम सत्यापनकर्ता को एक नए ईमेल के रूप में और मौजूदा पतों के संपादन के रूप में लटकाते हैं
• debug: true
  विधि फ़ॉर्म सबमिशन को निष्क्रिय कर देती है ताकि आप सेटिंग्स के साथ मज़े कर सकें
• rules:
  फ़ील्ड के लिए सत्यापन नियम विधि में लिखे गए हैं, प्लगइन में उनमें से बहुत सारे बॉक्स हैं (डॉक देखें), लेकिन अभी तक हम केवल 2 में रुचि रखते हैं
• 'email[email]':
  नाम - प्रपत्र फ़ील्ड की विशेषता (सरल नाम उद्धरण के बिना इंगित किए जाते हैं, विशेष वर्णों के साथ - उद्धरणों में लें)

दूरस्थ

 remote: url: validate_url type: 'post' 

• जवाब true - इसका मतलब है कि क्षेत्र के साथ सब कुछ ठीक है
• false , undefined या null , साथ ही किसी भी अन्य string' विधि द्वारा असफल मान्यता के संकेत के रूप में माने जाते हैं

अपेक्षित

 required: true 

जारी रखने के लिए

• आपको नियंत्रक में एक विधि बनाने की आवश्यकता है जो अनुरोध को संभाल लेगी
• इस विधि के लिए एक मार्ग पंजीकृत करें

  def validate #   end 

 resources :emails post 'emails/validate', to: 'emails#validate', as: :emails_validation 

 Started POST "/emails/validate" for 127.0.0.1 at 2014-02-17 22:10:31 +0000 Processing by EmailsController#validate as JSON Parameters: {"email"=>{"frequency"=>"-"}} 

• कंट्रोलर में आने वाले json से, हम मेमोरी में एक नया Email ऑब्जेक्ट बनाएंगे
• और ActiveModel माध्यम से इसके सत्यापन को खींचें
• एक ActiveModel::Errors वर्ग ऑब्जेक्ट मेमोरी में ActiveModel::Errors जाएगी ( errors विधि के माध्यम से सुलभ), जिसमें एक @messages हैश होगा - या तो त्रुटियों के साथ (यदि विशेषताएँ सत्यापन पारित नहीं किया था) या खाली (यदि सब कुछ ऑब्जेक्ट के साथ ठीक है)
• हम इस हैश का विश्लेषण करेंगे और, यदि यह खाली है, तो हम ब्राउज़र के true उत्तर देंगे, और यदि इसमें विशेषता के लिए त्रुटियां हैं, तो हम इन त्रुटियों के पाठ के साथ उत्तर देंगे, जिसे प्लग-इन की प्राप्त विधि द्वारा विफल सत्यापन के रूप में माना जाएगा। और, इसके अलावा, प्लगइन त्रुटि संदेश के पाठ के रूप में प्राप्त स्ट्रिंग का उपयोग करता है।

 ru: activerecord: attributes: email: email: "" frequency: "" errors: models: email: attributes: email: blank: "" taken: "    " invalid: "  " frequency: inclusion: "     1  7 " 

हमने रेल गाइड में I18n के बारे में पढ़ा: http://guides.rubyonrails.org/i18n.html

 def validate email = Email.new(email_params) email.valid? field = params[:email].first[0] @errors = email.errors[field] if @errors.empty? @errors = true else name = t("activerecord.attributes.email.#{field}") @errors.map! { |e| "#{name} #{e}<br />" } end respond_to do |format| format.json { render json: @errors } end end 

 email = Email.new(email_params) email.valid? 

 (rdb:938) email.errors #=> #<ActiveModel::Errors:0x007fbbe378dfb0 @base=#<Email id: nil, email: nil, frequency: "-", created_at: nil, updated_at: nil>, @messages={:email=>["", "  "], :frequency=>["     1  7 "]}> 

 (rdb:938) email.errors['frequency'] #=> ["     1  7 "] 

 #    (rdb:938) params #=> {"email"=>{"frequency"=>"-"}, "controller"=>"emails", "action"=>"validate"} #    ,    (rdb:938) params[:email] #=> {"frequency"=>"-"} #       ,    (rdb:938) params[:email].first #=> ["frequency", "-"] #      ,     ->  (rdb:938) params[:email].first[0] #=> "frequency" 

 field = params[:email].first[0] @errors = email.errors[field] 

 if @errors.empty? @errors = true else name = t("activerecord.attributes.email.#{field}") @errors.map! { |e| "#{name} #{e}<br />" } end 

• यदि हम इसे केवल @errors रूप में देते हैं, तो हमें संदेश मिलता है कि "1 से 7 समावेशी की सीमा में होना चाहिए" (और यदि कई हैं, तो वे आउटपुट पर "एक साथ चिपकते हैं")

• रेल स्थानीयकरण फ़ाइल से मॉडल विशेषता नाम खींचें:
  name = t("activerecord.attributes.email.#{field}")
• और त्रुटियों वाले सरणी के प्रत्येक तत्व में, इस नाम को एक स्थान के साथ शुरुआत में जोड़ें:
  @errors.map! { |e| "#{name} #{e}
" }
• आप प्रत्येक त्रुटि के अंत में भी छड़ी कर सकते हैं, यह लेआउट पर निर्भर करता है, स्वाद के लिए संक्षेप में

 respond_to do |format| format.json { render json: @errors } end 

refactor

मार्ग

 #  post 'emails/validate', to: 'emails#validate', as: :emails_validation #        post ':controller/validate', action: 'validate', as: :validate_form 

मान्यता विधि

 def validator(object) object.valid? model = object.class.name.underscore.to_sym field = params[model].first[0] @errors = object.errors[field] if @errors.empty? @errors = true else name = t("activerecord.attributes.#{model}.#{field}") @errors.map! { |e| "#{name} #{e}<br />" } end end 

 def validate email = Email.new(email_params) validator(email) respond_to do |format| format.json { render json: @errors } end end