ruby on rails - rails - after_commit para un atributo

ruby on rails tutorial

Question

Estoy usando un after_commit en mi aplicación.

Me gustaría que se active solo cuando se actualiza un campo en particular en mi modelo. ¿Alguien sabe cómo hacer eso?

Answer 1

Este es un problema muy antiguo, pero la solución previous_changes aceptada simplemente no es lo suficientemente robusta. En una transacción de ActiveRecord , hay muchas razones por las que puede guardar un Modelo dos veces. previous_changes solo refleja el resultado del último save . Considera este ejemplo

class Test < ActiveRecord::Base
  after_commit: :after_commit_test

  def :after_commit_test
    puts previous_changes.inspect
  end
end

test = Test.create(number: 1, title: "1")
test = Test.find(test.id) # to initialize a fresh object

test.transaction do
  test.update(number: 2)
  test.update(title: "2")
end

qué salidas:

{"title"=>["1", "2"], "updated_at"=>[...]}

pero, lo que necesitas es:

{"title"=>["1", "2"], "number"=>[1, 2], "updated_at"=>[...]}

Entonces, mi solución es esta:

module TrackSavedChanges
  extend ActiveSupport::Concern

  included do
    # expose the details if consumer wants to do more
    attr_reader :saved_changes_history, :saved_changes_unfiltered
    after_initialize :reset_saved_changes
    after_save :track_saved_changes
  end

  # on initalize, but useful for fine grain control
  def reset_saved_changes
    @saved_changes_unfiltered = {}
    @saved_changes_history = []
  end

  # filter out any changes that result in the original value
  def saved_changes
    @saved_changes_unfiltered.reject { |k,v| v[0] == v[1] }
  end

  private

  # on save
  def track_saved_changes
    # maintain an array of ActiveModel::Dirty.changes
    @saved_changes_history << changes.dup
    # accumulate the most recent changes
    @saved_changes_history.last.each_pair { |k, v| track_saved_change k, v }
  end

  # v is an an array of [prev, current]
  def track_saved_change(k, v)
    if @saved_changes_unfiltered.key? k
      @saved_changes_unfiltered[k][1] = track_saved_value v[1]
    else
      @saved_changes_unfiltered[k] = v.dup
    end
  end

  # type safe dup inspred by http://.com/a/20955038
  def track_saved_value(v)
    begin
      v.dup
    rescue TypeError
      v
    end
  end
end

que puedes probar aquí: github.com/ccmcbeck/after-commit

Answer 2

No creo que puedas hacerlo en after_commit

Se llama al after_commit después de que la transacción se haya comprometido. Rails Transactions

Por ejemplo en mi consola de rieles

> record = MyModel.find(1)
=> #<MyModel id: 1, label: "test", created_at: "2011-08-19 22:57:54", updated_at: "2011-08-19 22:57:54">
> record.label = "Changing text"
=> "Changing text"
> record.label_changed?
=> true
> record.save
=> true
> record.label_changed?
=> false 

Por lo tanto, no podrá usar la condición :if en after_commit porque el atributo ya no se marcará como cambiado ya que se ha guardado. ¿Es necesario que rastree si el campo que busca ha changed? en otra devolución de llamada antes de que se guarde el registro?

Answer 3

Parece que quieres algo así como una devolución de llamada condicional . Si hubiera publicado algún código, podría haberlo señalado en la dirección correcta; sin embargo, creo que le gustaría usar algo como esto:

after_commit :callback,
  :if => Proc.new { |record| record.field_modified? }

Answer 4

Una vieja pregunta, pero este es un método que he encontrado que podría funcionar con la devolución de llamada after_commit (trabajando en la respuesta de paukul ). Al menos, los valores persisten después de la confirmación en IRB.

after_commit :callback, 
  if: proc { |record| 
    record.previous_changes.key?(:attribute) &&
      record.previous_changes[:attribute].first != record.previous_changes[:attribute].last
  }

Answer 5

Usa gem ArTransactionChanges . previous_changes no funciona para mí en Rails 4.0.x

Uso:

class User < ActiveRecord::Base
  include ArTransactionChanges

  after_commit :print_transaction_changes

  def print_transaction_changes
    transaction_changed_attributes.each do |name, old_value|
      puts "attribute #{name}: #{old_value.inspect} -> #{send(name).inspect}"
    end
  end
end

Answer 6

Respondiendo a esta vieja pregunta porque aún aparece en los resultados de búsqueda

puede usar el método previous_changes que devuelve un hash del formato:

{"changed_attribute" => ["valor antiguo", "valor nuevo"]}

es lo que changes hasta que el registro se guarda realmente (desde active_record / attribute_methods / dirty.rb):

  def save(*) #:nodoc:
    if status = super
      @previously_changed = changes
      @changed_attributes.clear
      # .... whatever goes here

entonces en tu caso puedes verificar por previous_changes.key? "your_attribute" previous_changes.key? "your_attribute" o algo así