मैं कैसे सत्यापित करूं कि दो मान रेल मॉडल में एक दूसरे के बराबर नहीं हैं?

Question

मेरे पास एक उपयोगकर्ता मॉडल है, जिसमें एक ईमेल और पासवर्ड फ़ील्ड है। सुरक्षा के लिए, ये एक-दूसरे के बराबर नहीं हो सकते हैं। मैं इसे अपने मॉडल में कैसे परिभाषित कर सकता हूं?

Answer 1

Create custom validataion:

validate :check_email_and_password 

def check_email_and_password 
    errors.add(:password, "can't be the same as email") if email == password 
end 

लेकिन ध्यान रखें कि एक सादा पाठ के रूप में पासवर्ड भंडारण बुरा विचार है। आपको इसे धोया जाना चाहिए। authlogic या Restful authentication जैसे कुछ प्रमाणीकरण प्लगइन आज़माएं।

class User < ActiveRecord::Base 
    # ... 
    validates_with ValuesNotEqualValidator, fields: [:email, :password], msg: "This Person is evil" 
end 

Answer 2

आप इसे जांचने के लिए एक कस्टम सत्यापन विधि का उपयोग कर सकते हैं।

class User < ActiveRecord::Base 
    # ... 

    def validate 
    if (self.email == self.password) 
     errors.add(:password, "password cannot equal email") 
     errors.add(:email, "email cannot equal password") 
    end 
    end 
end 

Answer 3

आप सभी की जरूरत उदाहरण के लिए अपने मॉडल में सत्यापन नियम बनाने के लिए है

class User < ActiveRecord::Base 
    def validate_on_create 
    if email == password 
     errors.add("password", "email and password can't be the same") 
    end 
    end 
end 

Answer 4

यह निर्भर करता है कि कैसे आपका पासवर्ड संग्रहीत किया जाता है:

class User < ActiveRecord::Base 
    validate :email_and_password_validation 

    def email_and_password_validation 
     if self.email == self.password 
      errors.add_to_base("Password must be different from email") 
     end 
    end 
end 

यह अगर आपका पासवर्ड है काम करेगा सचमुच संग्रहित है, लेकिन आप ईमेल के साथ एक ही चीज़ कर सकते हैं (उदाहरण के लिए एक हैश संस्करण बनाएं) और पासवर्ड के साथ समानता की जांच करें। उदा:

class User < ActiveRecord::Base 
    validate :email_and_password_validation 

    def email_and_password_validation 
     if make_hash(self.email) == self.hashed_password 
      errors.add_to_base("Password must be different from email") 
     end 
    end 
end 

मेरे उदाहरण http://api.rubyonrails.org/classes/ActiveRecord/Validations/ClassMethods.html#M002162

आपका स्थिति से लिया जाता है काफी सामान्य है, तो आप कस्टम सत्यापन विधि बनाने में रुचि हो सकती है। यहाँ सब कुछ कवर किया जाता है: http://guides.rubyonrails.org/active_record_validations_callbacks.html#creating-custom-validation-methods

Answer 5

यह कस्टम सत्यापनकर्ता उपयोग करने के लिए बहुत समझदार है, यहाँ कि

class ValuesNotEqualValidator < ActiveModel::Validator 
    def validate(record) 
    if options[:fields].any? && options[:fields].size >= 2 
     field_values = options[:fields].collect { |f| record.send(f) } 
     unless field_values.size == field_values.uniq.size 
     record.errors[:base] << 
      (options[:msg].blank? ? "fields: #{options[:fields].join(", ")} - should not be equal" : 
       options[:msg]) 
     end 
    else 
     raise "#{self.class.name} require at least two fields as options [e.g. fields: [:giver_id, :receiver_id]" 
    end 
    end 
end 

इस्तेमाल किया जा सकता है और फिर इसे पसंद का उपयोग सार्वभौमिक सत्यापनकर्ता के लिए कोड है , आपको एक और समाधान के साथ आना होगा, जो त्रुटि संदेशों और विशेषता नामों का अनुवाद करता है। तो मैंने इसके लिए एक नया सत्यापनकर्ता बनाया।

validators/values_not_equal_validator.rb:

class ValuesNotEqualValidator < ActiveModel::EachValidator 
    def validate(record) 
    @past = Hash.new 
    super 
    end 

    def validate_each(record, attribute, value) 
    @past.each do |k, v| 
     if v == value 
     record.errors.add(attribute, I18n.t('errors.messages.should_not_be_equal_to') + " " + record.class.human_attribute_name(k)) 
     end 
    end 
    @past[attribute] = value 
    end 
end 

मैं इस तरह के मॉडल में इसे कहते:

class User < ActiveRecord::Base 
    validates :forename, :surname, values_not_equal: true 
end 

और मैं इसे इस तरह संदेशों का अनुवाद:

de: 
    activerecord: 
    attributes: 
     user: 
     forename: 'Vorname' 
     surname: 'Nachname' 
    errors: 
    messages: 
     should_not_be_equal_to: 'darf nicht gleich sein wie' 

Answer 6

आप एकाधिक भाषाओं का समर्थन करना चाहते हैं:

Answer 7

नया तरीका:

validates :password, exclusion: { in: lambda{ |user| [user.email] } } 

या:

validates :password, exclusion: { in: ->(user) { [user.email] } }