How to fetch previous values of associated records? - ruby-on-rails

Question

When working with many-to-many relationships, I need to maintain a log file recording the changed values.
Using the before_save and after_save callbacks works fine for the main (has_many) model itself but in the before_save callback the associated (belongs_to) records appear to be updated already!
It seems rather odd to see that some parts of the data already have been updated before the 'before_save' callback is called.
Also, using callbacks in the associated model reveals that there is no before_destroy executed. Only the before_save gets called and shows the new values.
I also tried the :prepend => :true option but that didn't gave other results.
When turning on SQL logging before the actual save in the main (has_many) model, I can see Rails is fetching the associated records, determines the differences and deletes the surplus record(s). The before_destroy of the associated model is not called.
It then calls the before_save of the associated model and inserts the new ones (if any) and commits the transaction. This is all done JUST BEFORE the before_save of the main model.
Does anyone know how to fetch the associated records before they are changed?
I would expect the before_destroy of the associated model would get called and let me handle it.

Answer 1

Use before_update and you can access old values using _was
before_update :record_values
def record_values
p "oldvalue: #{self.field_was} Newvalue: #{self.field}"
end

Answer 2

Your question is a bit unclear, but let me provide you with an example of what I think you try to do.
The code below works fine for me:
class Person < ApplicationRecord
has_many :addresses
validates_presence_of :name
before_save { puts "before_save of person - changes: #{changes}" }
before_destroy { puts "before_destroy of person with id: #{id}" }
end
class Address < ApplicationRecord
belongs_to :person, required: true
validates_presence_of :name
before_save { puts "before_save of address - changes: #{changes}" }
before_destroy { puts "before_destroy of address with id: #{id}" }
end
This results in the following output when interacting:
person = Person.create(name: 'Johan Wentholt')
# before_save of person - changes: {"name" =>[nil, "Johan Wentholt"]}
#=> #<Person id: 2, name: "Johan Wentholt", created_at: "2017-10-25 15:04:27", updated_at: "2017-10-25 15:04:27">
person.addresses.create(name: 'Address #1')
# before_save of address - changes: {"person_id"=>[nil, 2], "name" =>[nil, "Address #1"]}
#=> #<Address id: 7, person_id: 2, name: "Address #1", created_at: "2017-10-25 15:06:38", updated_at: "2017-10-25 15:06:38">
person.addresses.last.update(name: 'Address without typo')
# before_save of address - changes: {"name"=>["Address #1", "Address without typo"]}
#=> true
person.update(name: 'Kaasboer')
# before_save of person - changes: {"name"=>["Johan Wentholt", "Kaasboer"]}
#=> true
person.addresses.last.destroy
# before_destroy of address with id: 7
#=> #<Address id: 7, person_id: 2, name: "Address without typo", created_at: "2017-10-25 15:06:38", updated_at: "2017-10-25 15:08:51">
person.destroy
# before_destroy of person with id: 2
#=> #<Person id: 2, name: "Kaasboer", created_at: "2017-10-25 15:04:27", updated_at: "2017-10-25 15:10:46">
As you can see this logs all changes. Like I said, the question is a bit unclear, but I hope this helps you further.
Keep in mind that some Rails methods don't trigger callbacks. For example: delete, update_all, update_column and some others.
For more about changes take a look at: ActiveModel::Dirty

Answer 3

For clarity sake, lets give some extended information:
class Book < ActiveRecord::Base
unloadable
has_many :titles, dependent: :destroy
has_many :authors, :through => :titles
accepts_nested_attributes_for :authors
before_save :pre_save
after_save :post_save
before_destroy :pre_delete
def pre_save
#nr = self.new_record?
end
def pre_save
changed_values = []
if #nr
changed_values.push "New record created"
else
self.changes.each do |field, cvs|
changes.push("#{field} : #{cvs[0]} => #{cvs[1]}")
end
end
if changes.length > 0
BookLog.create(:book_id => self.id, :changed_values => changes.join(', '))
end
end
def pre_delete
BookLog.create(:book_id => self.id, :changed_values => "Deleted: #{self.name}")
end
end
class Title < ActiveRecord::Base
unloadable
belongs_to :book
belongs_to :author
end
class Author < ActiveRecord::Base
unloadable
has_many :titles, dependent: :destroy
has_many :books, :through => :titles
accepts_nested_attributes_for :books
end
class BooksController < ApplicationController
def edit
book = Book.find(params[:book][:id])
book.name = .....
===> Here the old values are still available <====
book.author_ids = params[:book][:author_ids]
===> Now the new values are written to the database! <====
book.save!
end
end
Changes to the Book record are perfectly logged.
But there is no way to fetch the changed associated values for author_ids.
A before_destroy callback in Title was not called, the after_save was.
I checked this with enabling the SQL logging just before the assignment of the new author_ids to the edited record. I could see that Rails determines the differences between the existing and new associated values, deletes the surplus form the Titles table and insert the extra ones (if any)
I solved it by moving the logging for the changes in Titles to the Books controller by comparing the old with the new values:
o_authors = book.author_ids
n_authors = params[:book][:author_ids].collect {|c| c.to_i}
diff = o_authors - n_authors | n_authors - o_authors
if !diff.empty?
changed_values = []
(o_authors - n_authors).each do |d|
changed_values.push("Removed Author: #{Author.find(d).name}")
end
(n_authors - o_authors).each do |d|
changed_values.push("Added Author: #{Author.find(d).name}")
end
BookLog.create(:book_id => book.id, :changed_values => changed_values)
end
book.author_ids = params[:book][:author_ids]
book.save!
Like I said, it works but IMHO it does not reflect the Rails way of doing things. I would have expected to get the previous author_ids in the same way as any other Book attribute.