Gibt es eine Möglichkeit zu überprüfen, die ein bestimmtes Attribut auf ein ActiveRecord-ohne Instanziierung ein Objekt zuerst?

Zum Beispiel, wenn ich einen Benutzer-Modell, und ich brauche, um zu validieren login nur (was passieren kann, wenn die Validierung eines Formulars per ajax), wäre es toll, wenn ich mit dem gleichen Modell-Validierungen Definition in der User-Modell, ohne tatsächlich zu instanziieren einer User-Instanz.

Also den controller würde ich in der Lage, code zu schreiben, wie

User.valid_attribute?(:login, "login value")

Ist es trotzdem kann ich dies tun?

InformationsquelleAutor humanzz | 2009-01-19

20

Seit Validierungen operieren auf Instanzen (und Sie nutzen die Fehler-Attribut einer Instanz als container für Fehlermeldungen), können Sie Sie nicht benutzen, ohne das Objekt instanziiert. Having said, die, können Sie verstecken diese benötigte Verhalten in einer Methode der Klasse:
```
class User < ActiveRecord::Base
  def self.valid_attribute?(attr, value)
    mock = self.new(attr => value)
    unless mock.valid?
      return mock.errors.has_key?(attr)
    end
    true
  end
end
```
Nun, Sie können rufen Sie
```
User.valid_attribute?(:login, "login value")
```
so wie Sie soll.

(Im Idealfall würden Sie unter anderem, dass class-Methode direkt in den ActiveRecord::Base, so würde es vorhanden sein, um jedes Modell.)
- Beachten Sie, dass pro Timo ' s Antwort unten, die Linie return mock.errors.has_key?(attr) definitiv sein return (not mock.errors.has_key?(attr)). Andere, als dass die Antwort, die funktioniert.
InformationsquelleAutor Milan Novota
5

Danke Milan für deine Anregung. Davon inspiriert erstellte ich ein einfaches Modul kann man verwenden, um diese Funktionalität hinzuzufügen für jede Klasse. Beachten Sie, dass die ursprüngliche Milans Vorschlag hat ein Logik-Fehler Zeile:
```
return mock.errors.has_key?(attr)
```
sollte klar sein:
```
return (not mock.errors.has_key?(attr))
```
Getestet hab ich meine Lösung und es sollte funktionieren, aber ofc gebe ich keine Garantien. Und hier meine glorreiche Lösung. Im Grunde ein 2-liner, wenn Sie nehmen Sie das Modul Zeug.. Es akzeptiert Methodennamen als Stiche oder Symbole.
```
module SingleAttributeValidation

  def self.included(klass)
    klass.extend(ClassMethods)
  end

  module ClassMethods
    def valid_attribute?(attr, value)
      mock = self.new(attr => value)
      (not mock.valid?) && (not mock.errors.has_key?(attr.class == Symbol ? attr : attr.to_sym))
    end
  end
end
```
InformationsquelleAutor Timo

Verwenden Sie Ihre standard-Validierungs-Routinen:


User.new(:login => 'login_value').valid?

Wenn das nicht für Sie arbeiten, erstellen Sie eine benutzerdefinierte Klasse Methode:


class User < ActiveRecord::Base

  validate do |user|
    user.errors.add('existing') unless User.valid_login?(user.login)
  end

  def self.valid_login?(login)
    # your validation here
    !User.exist?(:login=> login)
  end
end

InformationsquelleAutor wvanbergen

2

Ich hatte einen Teufel einer Zeit bekommen, diese Arbeit in Rails 3.1. Dies endlich funktionierte. (Nicht sicher, ob es der beste Weg, es zu tun, ich bin irgendwie ein newb.). Das problem, das ich hatte war, dass Wert wurde eingestellt, um Typ-ActiveSupport::SafeBuffer, und wurde nicht Validierung.
```
def self.valid_attribute?(attr, value)
  mock = User.new(attr => "#{value}") # Rails3 SafeBuffer messes up validation
  unless mock.valid?
    return (not mock.errors.messages.has_key?(attr))
  end
  return true
end
```
- Ok, das liegt zum Teil an mir mit ActionController::Base.helpers.sanitize(params[:email]) im controller, bevor Sie ihn in das Modell. Aber die errors.messages.has_key? noch Rails3 bestimmten.
InformationsquelleAutor Excalibur

Ich habe mit der benutzerdefinierten Klasse Lösung, aber ich wollte nur, um sicherzustellen, dass es keinen besseren Weg,

class ModelValidator
  def self.validate_atrribute(klass, attribute, value)
    obj = Klass.new
    obj.send("#{attribute}=", value)
    obj.valid?
    errors = obj.errors.on(attribute).to_a
    return (errors.length > 0), errors 
  end
end

und ich können es verwenden, wie

gültig, Fehler = ModelValidator.validate_attribute(Benutzer, "login", "humanzz")

InformationsquelleAutor humanzz

class User < ActiveRecord::Base
  validates_each :login do |record, attr, value|
    record.errors.add attr, 'error message here' unless User.valid_login?(value)
  end

  def self.valid_login?(login)
    # do validation
  end
end

Nur call User.valid_login?(login), um zu sehen, wenn die Anmeldung selbst ist gültig

InformationsquelleAutor aivarsak

Einer Umsetzung der "valid_attribute' Methode, die Sie vorschlagen:

class ActiveRecord:Base
  def self.valid_attribute?(attribute, value)
    instance = new
    instance[attribute] = value
    instance.valid?

    list_of_errors = instance.errors.instance_variable_get('@errors')[attribute]

    list_of_errors && list_of_errors.size == 0
  end
end

InformationsquelleAutor August Lilleaas

0

Wie etwa:

Benutzer.columns_hash.has_key?('login')

InformationsquelleAutor

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.