Rails ActiveRecord: blocco degli attributi quando il record entra in uno stato particolare

Question

Chiedere se esiste un plug-in o il modo migliore per impostare una classe ActiveRecord in modo che, ad esempio, quando un record entri nello stato "pubblicato", alcuni attributi vengono congelati che non potevano essere manomessi.

Answer 1

È possibile bloccare un intero oggetto AR :: B impostando @readonly su true (in un metodo), ma questo bloccherà tutti gli attributi.

Il modo in cui mi sento di raccomandare è di definire i metodi attributo setter che controllano lo stato attuale prima di passare a super:

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

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

[EDIT] O per una grande quantità di attributi:

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 

Che ovviamente vorrei inserire in un plug-in per condividere con altri, e aggiungere un bel DSL per l'accesso come: disable_attributes :author, :content, :comments, :when => :published?

Answer 2

Si potrebbe aggiungere ac convalida di ustom per bloccare le modifiche agli attributi se ti trovi in ​​un determinato stato. È possibile codificare direttamente le cose direttamente nella convalida. Ma preferisco l'approccio un po 'più robusto usando le costanti che definiscono una lista bianca (lista di attributi che possono cambiare in uno stato) o una lista nera (lista di attributi che non possono cambiare in uno stato).

Ecco un esempio di entrambi gli approcci. Ogni approccio presuppone che ci sia un metodo di stato nel modello che restituisce lo stato corrente/nuovo come una stringa.

White List Approccio

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 

approccio nero Lista

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

Editing attributi che non deve essere modificato è un errore di convalida:

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 usa le estensioni ActiveRecord::Dirty introdotte in 2.2 circa.

Answer 4

Se lo stato particolare è semplicemente persisted?, quindi attr_readonly è l'opzione migliore.

attr_readonly(*attributes)pubblico

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

Per testare (per gentile concessione di 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