Come salvare qualcosa nel database dopo le convalide di ActiveRecord fallite?

Question

Fondamentalmente quello che voglio fare è registrare un'azione su MyModel nella tabella di MyModelLog. Ecco alcuni pseudo codice:

class MyModel < ActiveRecord::Base 
    validate :something 

    def something 
    # test 
    errors.add(:data, "bug!!") 
    end 
end 

ho anche un modello simile a questo:

class MyModelLog < ActiveRecord::Base 

    def self.log_something 
    self.create(:log => "something happened") 
    end 

end 

Per accedere Ho cercato di:

• Aggiungere MyModelLog.log_something nel metodo di somethingMyModel

• Chiama MyModelLog.log_something sulla after_validation callback di MyModel

In entrambi i casi la creazione è rotolato indietro quando la convalida non riesce, perché è nella transazione convalida. Naturalmente voglio anche loggare quando falliscono le validazioni. Non voglio veramente accedere a un file o da qualche altra parte rispetto al database perché ho bisogno delle relazioni delle voci di registro con altri modelli e della capacità di fare richieste.

Quali sono le mie opzioni?

Answer 1

È possibile utilizzare una transazione nidificata. In questo modo il codice nel callback viene eseguito in una transazione diversa dalla convalida non riuscita. Le documentazioni Rails per ActiveRecord::Transactions::ClassMethods discutono di come è fatto.

Answer 2

Non sono sicuro se si applica a te, ma presumo che stai cercando di salvare/creare un modello dal controller. Nel controller è facile controllare l'esito di tale azione, e molto probabilmente lo fai già per fornire all'utente un flash utile; così puoi facilmente registrare un messaggio appropriato lì.

Suppongo anche che non si utilizzino transazioni esplicite, quindi se lo gestisci nel controller, è fuori dalla transazione (ogni operazione di salvataggio e distruzione nella propria transazione).

Cosa ne pensi?

Answer 3

Questo dovrebbe essere adatto per un Observer? Non sono sicuro, ma spero che esista al di fuori della transazione ... Ho un'esigenza simile in cui potrei voler cancellare un record sull'aggiornamento ...

Answer 4

Le transazioni nidificate sembrano funzionare in MySQL .

Ecco quello che ho provato su un rotaie appena generati (con MySQL) progetto:

./script/generate model Event title:string --skip-timestamps --skip-fixture 

./script/generate model EventLog error_message:text --skip-fixture 

class Event < ActiveRecord::Base                                  
    validates_presence_of :title                                   
    after_validation_on_create :log_errors                                

    def log_errors                                      
    EventLog.log_error(self) if errors.on(:title).present?                            
    end                                         
end 

class EventLog < ActiveRecord::Base                                  
    def self.log_error(event)                                    
    connection.execute('BEGIN') # If I do transaction do then it doesn't work. 
    create :error_message => event.errors.on(:title)                        
    connection.execute('COMMIT')                                  
    end                                         
end 

# And then in script/console: 
>> Event.new.save 
=> false 
>> EventLog.all 
=> [#<EventLog id: 1, error_message: "can't be blank", created_at: "2010-10-22 13:17:41", updated_at: "2010-10-22 13:17:41">] 
>> Event.all 
=> [] 

Forse Ho più semplificato, o manca qualche punto.

Answer 5

MyModelLog.log_something deve essere eseguito utilizzando una connessione diversa.

È possibile fare in modo che il modello MyModelLog utilizzi sempre una connessione diversa utilizzando establish_connection.

class MyModelLog < ActiveRecord::Base 
    establish_connection Rails.env # Use different connection 

    def self.log_something 
    self.create(:log => "something happened") 
    end 
end 

Non so se questo è il modo giusto per fare il logging !!

Answer 6

Ho risolto un problema in questo modo sfruttando l'ambito della variabile di Ruby. Fondamentalmente ho dichiarato una variabile error al di fuori di un blocco di transazione, quindi catturare, memorizzare il messaggio di registro e sollevare nuovamente l'errore.

Sembra qualcosa di simile a questo:

def something 
    error = nil 
    ActiveRecord::Base.transaction do 
     begin 
      # place codez here 
     rescue ActiveRecord::Rollback => e 
      error = e.message 
      raise ActiveRecord::Rollback 
     end 
    end 
    MyModelLog.log_something(error) unless error.nil? 
end 

Dichiarando la error esterno variabile della portata dell'operazione il contenuto della variabile persistono anche dopo che la transazione è uscito.