Rails ActiveRecord: Sperren von Attributen, wenn Datensatz in einen bestimmten Zustand eintritt

Question

Fragen, ob es ein Plugin oder die beste Möglichkeit gibt, eine ActiveRecord-Klasse so einzurichten, dass zum Beispiel ein Datensatz in den "published" -Zustand eintritt dass sie nicht manipuliert werden könnten.

Answer 1

Sie können ein gesamtes AR :: B-Objekt einfrieren, indem Sie @readonly auf true (in einer Methode) festlegen. Dadurch werden jedoch alle Attribute gesperrt.

Die Art, wie ich empfehlen würde, ist durch Attribut Setter-Methoden definiert, die zu Super, bevor er für den aktuellen Zustand überprüfen:

class Post < ActiveRecord::Base 
    def author=(author) 
    super unless self.published? 
    end 

    def content=(content) 
    super unless self.published? 
    end 
end 

[EDIT] Oder für eine große Menge von Attributen:

class Post < ActiveRecord::Base 
    %w(author content comments others).each do |method| 
    class_eval <<-"end_eval", binding, __FILE__, __LINE__ 
     def #{method}=(val) 
     super unless self.published? 
     end 
    end_eval 
    end 
end 

Welche würde ich befürworten ziehen in ein Plugin mit anderen zu teilen, und fügen Sie eine schöne DSL für den Zugriff wie: disable_attributes :author, :content, :comments, :when => :published?

Answer 2

Sie könnten ac hinzufügen ustom-Validierung, um Änderungen an Attributen zu blockieren, wenn Sie sich in einem bestimmten Status befinden. Sie könnten Dinge direkt in die Validierung einprogrammieren. Aber ich bevorzuge den leicht robusteren Ansatz mit Konstanten, die eine Whitelist definieren (eine Liste von Attributen, die sich in einem Zustand ändern dürfen) oder eine Blacklist (Liste von Attributen, die sich in einem Zustand nicht ändern dürfen).

Hier ist ein Beispiel für beide Ansätze. Bei jedem Ansatz wird davon ausgegangen, dass in Ihrem Modell eine Statusmethode vorhanden ist, die den aktuellen/neuen Status als Zeichenfolge zurückgibt. Ansatz

White List

WhiteListStateLockMap = { 
    "state_1" => [ 
    "first_attribute_allowed_to_change_in_state_1", 
    "second_attribute_allowed_to_change_in_state_1", 
    ... 
    ], 
    "state_2" => [ 
    "first_attribute_allowed_to_change_in_state_2", 
    "second_attribute_allowed_to_change_in_state_2", 
    ... 
    ], 
    ... 
} 

validates :state_lock 

def state_lock 
    # ensure that all changed elements are on the white list for this state. 
    unless changed & WhiteListStateLockMap[state] == changed 
    # add an error for each changed attribute absent from the white list for this state. 
    (changed - WhiteListStateLockMap[state]).each do |attr| 
     errors.add attr, "Locked while #{state}" 
    end 
    end 
end 

Black List Ansatz

BlackListStateLockMap = { 
    "state_1" => [ 
    "first_attribute_not_allowed_to_change_in_state_1, 
    "second_attribute_not_allowed_to_change_in_state_1, 
    ... 
    ], 
    "state_2" => [ 
    "first_attribute_not_allowed_to_change_in_state_2", 
    "second_attribute_not_allowed_to_change_in_state_2", 
    ... 
    ], 
    ... 
} 

validates :state_lock 

def state_lock 
    # ensure that no changed attributes are on the black list for this state. 
    unless (changed & BlackListStateLockMap[state]).empty? 
    # add an error for all changed attributes on the black list for this state. 
    (BlackListStateLockMap[state] & changed).each do |attr| 
     errors.add attr, "Locked while #{state}" 
    end 
    end 
end 

Answer 3

Bearbeiten Attribute, die nicht bearbeitet werden sollte ein Überprüfungsfehler ist:

class Post < ActiveRecord::Base 
    validate :lock_down_attributes_when_published 

    private 

    def lock_down_attributes_when_published 
    return unless published? 

    message = "must not change when published" 
    errors.add(:title, message) if title_changed? 
    errors.add(:published_at, message) if published_at_changed? 
    end 
end 

Thi s verwendet die in 2.2 oder so eingeführten Erweiterungen ActiveRecord::Dirty.

Answer 4

Wenn der bestimmte Zustand nur persisted? ist, dann ist attr_readonly die beste Option.

attr_readonly(*attributes)öffentliche

Attributes listed as readonly will be used to create a new record but update operations will ignore these fields.

Um zu testen (mit freundlicher Genehmigung von THAiSi):

class MyModel < ActiveRecord::Base 
    attr_readonly :important_type_thingie 
end 

#RSpec 
describe MyModel do 
its('class.readonly_attributes') { should include "important_type_thingie" } 

it "should not update the thingie" do 
    m = create :my_model, :important_type_thingie => 'foo' 
    m.update_attributes :important_type_thingie => 'bar' 
    m.reload.important_type_thingie.should eql 'foo' 
end 
end