Comment puis-je valider que deux valeurs ne sont pas égaux les uns aux autres dans un Rails de modèle?

J'ai un modèle Utilisateur, qui dispose d'une adresse email et un mot de passe de domaine. Pour plus de sécurité, ces derniers peuvent ne pas être égaux les uns aux autres. Comment puis-je définir ce dans mon modèle?

C'est bizarre pourquoi, plus tard, la réponse a été acceptée, tandis que d'autres sont presque les mêmes?
c'est le plus court, celui qui marche sur les pas seulement de créer de
Merci pour l'explication. Néanmoins klew de réponse est plus court 😉
la réponse est correcte, pour autant qu'il va échouer de validation lorsque les champs sont égaux, mais il oublie de marquer à la fois de la problématique des champs.

InformationsquelleAutor | 2010-02-16

29

Créer des 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
```
Mais gardez à l'esprit que le stockage de mot de passe en texte brut est une mauvaise idée. Vous devez les stocker haché. Essayez certains plug-in d'authentification comme authlogic ou Réparateur d'authentification.

InformationsquelleAutor klew
10

Nouvelle façon:
```
validates :password, exclusion: { in: lambda{ |user| [user.email] } }
```
ou:
```
validates :password, exclusion: { in: ->(user) { [user.email] } }
```
- Veuillez préciser ce que vous entendez par "voie nouvelle". Qui ruby/rails est cette application?
- Il a travaillé au moins à partir de Rails de 3.2.22 / Ruby 2.2.6 - excellent court de solution. Merci.
InformationsquelleAutor hlcs

Vous pouvez utiliser un personnalisé méthode de validation pour vérifier cela.

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

InformationsquelleAutor John Feminella

4

Cela dépend de comment Votre mot de passe est stocké:
```
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
```
Cela ne peut fonctionner que si Votre mot de passe est stocké littéralement, mais Vous pouvez faire la même chose avec e-mail (par exemple, créer une version hachée) et vérifier l'égalité avec mot de passe. E. g:
```
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
```
Mon exemple est tiré de http://api.rubyonrails.org/classes/ActiveRecord/Validations/ClassMethods.html#M002162

Votre situation est assez générale, de sorte que Vous pouvez être intéressé par la création personnalisée de validation de la méthode. Tout est ici:
http://guides.rubyonrails.org/active_record_validations_callbacks.html#creating-custom-validation-methods
- Dernier lien donne 404
- Lien fixe (prises à partir de l'ancienne version de Rails Guides). Merci.
InformationsquelleAutor Dawid

il est beaucoup plus sage d'utiliser validateur personnalisé, voici le code universel du programme de validation qui peut être utilisé

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

et de l'utiliser ensuite comme:

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

InformationsquelleAutor cs3b

1

tous vous avez besoin est de créer une règle de validation de votre modèle
par exemple
```
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
```
- Je ne pense pas que cela est juste. Nous voulons validate, pas validate_on_create, parce que nous avons besoin de vérifier sur tous les jets de sauvegarde que l'adresse e-mail n'est pas le mot de passe (et pas seulement au moment de la création).
- Il y a une erreur de syntaxe (faute de frappe) dans le message d'erreur: Vous ne pouvez pas utiliser les guillemets simples, en chaîne, qui est une seule cité 😉
InformationsquelleAutor sys

Si vous souhaitez prendre en charge plusieurs langues, vous devez trouver une autre solution, qui traduit les messages d'erreur et les noms d'attribut. J'ai donc créé un nouveau chaque validateur pour que.

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

Je l'appelle dans le modèle comme ceci:

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

Et je traduire les messages comme ceci:

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

InformationsquelleAutor Robin

0

Par l'aide personnalisée, les validations que nous pouvons faire cette opération

valider :validate_address

def validate_address

erreurs.ajouter(:permenent_address, "ne peut pas être le même que present_address") si l'auto.present_address== self.permenent_address
fin

InformationsquelleAutor Ramakrishna

Vous devez vous connecter pour publier un commentaire.