Active Record Callbacks

class BirthdayCake < ApplicationRecord
  after_create -> { Rails.logger.info("축하합니다, callback이 실행되었습니다!") }
end

irb> BirthdayCake.create
축하합니다, callback이 실행되었습니다!

class User < ApplicationRecord
  validates :username, :email, presence: true

  before_validation :ensure_username_has_value

  private
    def ensure_username_has_value
      if username.blank? 
        self.username = email
      end
    end
end

class User < ApplicationRecord
  validates :username, :email, presence: true

  # validation 이전에 실행
  before_validation do
    # username이 비어있으면 email 값을 username에 할당
    self.username = email if username.blank?
  end
end

class User < ApplicationRecord
  validates :username, :email, presence: true

  # username이 비어있는 경우, validation 전에 username을 email로 설정
  before_validation ->(user) { user.username = user.email if user.username.blank? }
end

class User < ApplicationRecord 
  validates :username, :email, presence: true

  before_validation AddUsername 
end

class AddUsername
  def self.before_validation(record)
    if record.username.blank? 
      record.username = record.email
    end
  end
end

class User < ApplicationRecord
  validates :username, :email, presence: true

  before_validation :ensure_username_has_value, on: :create

  # :on은 배열도 받을 수 있습니다  
  after_validation :set_location, on: [ :create, :update ]

  private
    def ensure_username_has_value
      if username.blank?
        self.username = email
      end
    end

    def set_location
      self.location = LocationService.query(self)
    end
end

class User < ApplicationRecord
  validates :name, presence: true
  before_validation :titleize_name
  after_validation :log_errors

  private
    def titleize_name
      self.name = name.downcase.titleize if name.present?
      Rails.logger.info("이름이 #{name}으로 타이틀케이스화 되었습니다")
    end

    def log_errors
      if errors.any?
        Rails.logger.error("유효성 검사 실패: #{errors.full_messages.join(', ')}")
      end
    end
end

irb> user = User.new(name: "", email: "john.doe@example.com", password: "abc123456") 
=> #<User id: nil, email: "john.doe@example.com", created_at: nil, updated_at: nil, name: "">

irb> user.valid?
Name titleized to
유효성 검사 실패: Name은 비워둘 수 없습니다
=> false

class User < ApplicationRecord
  before_save :hash_password # 저장하기 전
  around_save :log_saving # 저장하는 동안 
  after_save :update_cache # 저장한 후

  private
    def hash_password
      self.password_digest = BCrypt::Password.create(password)
      Rails.logger.info("이메일이 #{email}인 사용자의 비밀번호가 해시되었습니다")
    end

    def log_saving
      Rails.logger.info("이메일이 #{email}인 사용자 저장 중")
      yield
      Rails.logger.info("이메일이 #{email}인 사용자가 저장되었습니다") 
    end

    def update_cache
      Rails.cache.write(["user_data", self], attributes)
      Rails.logger.info("캐시 업데이트")
    end
end

irb> user = User.create(name: "Jane Doe", password: "password", email: "jane.doe@example.com")

jane.doe@example.com 이메일을 가진 사용자의 비밀번호가 해시되었습니다
jane.doe@example.com 이메일을 가진 사용자를 저장합니다
jane.doe@example.com 이메일을 가진 사용자가 저장되었습니다
캐시 업데이트
=> #<User id: 1, email: "jane.doe@example.com", created_at: "2024-03-20 16:02:43.685500000 +0000", updated_at: "2024-03-20 16:02:43.685500000 +0000", name: "Jane Doe">

class User < ApplicationRecord
  before_create :set_default_role
  around_create :log_creation
  after_create :send_welcome_email

  private
    def set_default_role
      self.role = "user"
      Rails.logger.info("사용자 역할이 기본값으로 설정됨: user") 
    end

    def log_creation
      Rails.logger.info("이메일로 사용자 생성 중: #{email}")
      yield 
      Rails.logger.info("이메일로 사용자가 생성됨: #{email}")
    end

    def send_welcome_email
      UserMailer.welcome_email(self).deliver_later
      Rails.logger.info("환영 이메일이 다음 주소로 전송됨: #{email}")
    end
end

irb> user = User.create(name: "John Doe", email: "john.doe@example.com")

사용자 역할이 기본값으로 설정됨: user
이메일로 사용자 생성 중: john.doe@example.com  
이메일로 사용자 생성됨: john.doe@example.com
사용자 환영 이메일 발송됨: john.doe@example.com
=> #<User id: 10, email: "john.doe@example.com", created_at: "2024-03-20 16:19:52.405195000 +0000", updated_at: "2024-03-20 16:19:52.405195000 +0000", name: "John Doe">

class User < ApplicationRecord
  before_update :check_role_change
  around_update :log_updating
  after_update :send_update_email

  private
    def check_role_change
      if role_changed?
        Rails.logger.info("사용자 역할이 #{role}로 변경되었습니다") 
      end
    end

    def log_updating
      Rails.logger.info("이메일이 #{email}인 사용자를 업데이트하는 중")
      yield
      Rails.logger.info("이메일이 #{email}인 사용자 업데이트 완료")
    end

    def send_update_email
      UserMailer.update_email(self).deliver_later
      Rails.logger.info("#{email}로 업데이트 이메일 전송됨")
    end
end

irb> user = User.find(1)
=> #<User id: 1, email: "john.doe@example.com", created_at: "2024-03-20 16:19:52.405195000 +0000", updated_at: "2024-03-20 16:19:52.405195000 +0000", name: "John Doe", role: "user" >

irb> user.update(role: "admin") 
사용자 역할이 admin으로 변경됨
이메일이 john.doe@example.com인 사용자 업데이트 중
이메일이 john.doe@example.com인 사용자 업데이트 완료
업데이트 이메일이 다음 주소로 전송됨: john.doe@example.com

class User < ApplicationRecord
  after_create :send_confirmation_email
  after_update :notify_admin_if_critical_info_updated

  private
    def send_confirmation_email
      UserMailer.confirmation_email(self).deliver_later
      Rails.logger.info("확인 이메일이 다음 주소로 전송되었습니다: #{email}")
    end

    def notify_admin_if_critical_info_updated
      if saved_change_to_email? || saved_change_to_phone_number?
        AdminMailer.user_critical_info_updated(self).deliver_later
        Rails.logger.info("관리자에게 다음 사용자의 중요 정보 업데이트 알림이 전송되었습니다: #{email}")
      end
    end
end

irb> user = User.create(name: "John Doe", email: "john.doe@example.com") 
확인 이메일이 다음 주소로 전송되었습니다: john.doe@example.com
=> #<User id: 1, email: "john.doe@example.com", ...>

irb> user.update(email: "john.doe.new@example.com")
중요 정보 업데이트에 대한 알림이 관리자에게 전송되었습니다: john.doe.new@example.com  
=> true

class User < ApplicationRecord
  before_destroy :check_admin_count
  around_destroy :log_destroy_operation 
  after_destroy :notify_users

  private
    def check_admin_count
      if admin? && User.where(role: "admin").count == 1
        throw :abort
      end
      Rails.logger.info("관리자 수를 확인함")
    end

    def log_destroy_operation
      Rails.logger.info("ID가 #{id}인 사용자를 삭제하려고 함") 
      yield
      Rails.logger.info("ID가 #{id}인 사용자가 성공적으로 삭제됨")
    end

    def notify_users
      UserMailer.deletion_email(self).deliver_later
      Rails.logger.info("다른 사용자들에게 사용자 삭제에 대한 알림을 보냄")
    end
end

irb> user = User.find(1)
=> #<User id: 1, email: "john.doe@example.com", created_at: "2024-03-20 16:19:52.405195000 +0000", updated_at: "2024-03-20 16:19:52.405195000 +0000", name: "John Doe", role: "admin">

irb> user.destroy
관리자 수 확인됨
ID 1번 사용자를 삭제하려고 합니다
ID 1번 사용자가 성공적으로 삭제되었습니다
사용자 삭제에 대해 다른 사용자들에게 알림이 전송되었습니다

class User < ApplicationRecord
  after_initialize do |user|
    Rails.logger.info("객체가 초기화되었습니다!")
  end

  after_find do |user|
    Rails.logger.info("객체를 찾았습니다!")
  end
end

irb> User.new
객체를 초기화했습니다!
=> #<User id: nil>

irb> User.first
객체를 찾았습니다!
객체를 초기화했습니다!
=> #<User id: 1>

class User < ApplicationRecord
  after_touch do |user|
    Rails.logger.info("객체를 touch 했습니다")
  end
end

irb> user = User.create(name: "Kuldeep")
=> #<User id: 1, name: "Kuldeep", created_at: "2013-11-25 12:17:49", updated_at: "2013-11-25 12:17:49">

irb> user.touch
객체를 터치했습니다 
=> true

class Book < ApplicationRecord
  belongs_to :library, touch: true
  after_touch do
    Rails.logger.info("Book이 touch 되었습니다")
  end
end

class Library < ApplicationRecord
  has_many :books
  after_touch :log_when_books_or_library_touched

  private
    def log_when_books_or_library_touched
      Rails.logger.info("Book/Library가 touch 되었습니다") 
    end
end

irb> book = Book.last
=> #<Book id: 1, library_id: 1, created_at: "2013-11-25 17:04:22", updated_at: "2013-11-25 17:05:05">

irb> book.touch # book.library.touch를 트리거함
A Book was touched 
Book/Library was touched
=> true

class Order < ApplicationRecord
  before_save :normalize_card_number, if: :paid_with_card?
end

class Order < ApplicationRecord
  before_save :normalize_card_number,
    if: ->(order) { order.paid_with_card? }
end

class Order < ApplicationRecord
  before_save :normalize_card_number, if: -> { paid_with_card? }
end

class Comment < ApplicationRecord
  before_save :filter_content,
    if: [:subject_to_parental_control?, :untrusted_author?] # 자녀 보호가 필요하고 신뢰되지 않은 작성자인 경우에만 콘텐츠를 필터링
end

class Comment < ApplicationRecord
  before_save :filter_content,
    if: [:subject_to_parental_control?, -> { untrusted_author? }]
    # 안전성 검사 및 미인증 작성자 여부가 true일 때 content를 필터링합니다
end

class Comment < ApplicationRecord
  before_save :filter_content,
    if: -> { forum.parental_control? },
    unless: -> { author.trusted? } # author가 trusted가 아닌 경우에만 
                                  # forum이 parental control을 사용하면 content를 필터링
end

class User < ApplicationRecord
  before_save :log_email_change

  private
    def log_email_change
      if email_changed?
        Rails.logger.info("이메일이 #{email_was}에서 #{email}로 변경되었습니다")
      end
    end
end

irb> user = User.find(1)
irb> user.update_columns(email: 'new_email@example.com')

class User < ApplicationRecord
  has_many :notifications

  after_create :create_welcome_notification

  def create_welcome_notification
    notifications.create(event: "sign_up") 
  end
end

class Notification < ApplicationRecord
  belongs_to :user
end

Notification.suppress 내에서는
  User.create(name: "Jane", email: "jane@example.com")
end

class Product < ActiveRecord::Base
  before_validation do
    raise "가격은 음수가 될 수 없습니다" if total_price < 0
  end
end

Product.create # "가격은 음수가 될 수 없습니다" 에러 발생

class Product < ActiveRecord::Base
  before_validation do
    total_price가 0보다 작으면 throw :abort 실행
  end
end

Product.create # => false

User.create! # => ActiveRecord::RecordNotSaved 예외를 발생시킴

class User < ActiveRecord::Base
  before_destroy do
    아직 활성화된 상태면 :abort를 throw하여 종료
    throw :abort if still_active?  
  end
end

User.first.destroy # => false

User.first.destroy! # => ActiveRecord::RecordNotDestroyed 에러를 발생시킴

class Author < ApplicationRecord
  has_many :books, before_add: :check_limit

  private
    def check_limit(_book)
      if books.count >= 5
        errors.add(:base, "이 저자는 5권 이상의 책을 추가할 수 없습니다")
        throw(:abort)
      end
    end
end

class Author < ApplicationRecord
  has_many :books, before_add: [:check_limit, :calculate_shipping_charges]

  def check_limit(_book)
    if books.count >= 5
      errors.add(:base, "이 저자는 5권 이상의 책을 추가할 수 없습니다")
      throw(:abort)
    end
  end

  def calculate_shipping_charges(book)
    weight_in_pounds = book.weight_in_pounds || 1  
    shipping_charges = weight_in_pounds * 2

    shipping_charges
  end
end

# `before_add` 콜백을 발생시킴
author.books << book
author.books = [book, book2]

# `before_add` 콜백을 발생시키지 않음
book.update(author_id: 1)

class User < ApplicationRecord
  has_many :articles, dependent: :destroy # User가 삭제되면 연관된 articles도 함께 삭제됨
end

class Article < ApplicationRecord
  after_destroy :log_destroy_action # Article이 삭제된 후에 log_destroy_action 메서드 실행 

  def log_destroy_action
    Rails.logger.info("Article destroyed") # Article이 삭제되었다는 로그 메시지를 기록
  end
end

irb> user = User.first
=> #<User id: 1>
irb> user.articles.create!
=> #<Article id: 1, user_id: 1>
irb> user.destroy
Article이 삭제됨
=> #<User id: 1>

class PictureFile < ApplicationRecord
  after_destroy :delete_picture_file_from_disk

  def delete_picture_file_from_disk
    if File.exist?(filepath) 
      File.delete(filepath)
    end
  end
end

PictureFile.transaction do
  picture_file_1.destroy
  picture_file_2.save!
end

class PictureFile < ApplicationRecord
  after_commit :delete_picture_file_from_disk, on: :destroy

  def delete_picture_file_from_disk
    if File.exist?(filepath) # 파일이 존재하면
      File.delete(filepath) # 디스크에서 파일 삭제
    end
  end
end

class User < ActiveRecord::Base
  after_commit { raise "Intentional Error" }
  after_commit {
    # 이전 after_commit이 예외를 발생시키기 때문에 이것은 호출되지 않습니다
    Rails.logger.info("This will not be logged")
  }
end

class User < ActiveRecord::Base
  after_save do
    # 이 작업이 실패하면 user가 저장되지 않습니다.
    EventLog.create!(event: "user_saved")
  end
end

class User < ActiveRecord::Base
  after_commit do
    # 만약 실패하더라도 user는 이미 저장된 상태입니다.
    EventLog.create!(event: "user_saved")
  end
end

class User < ApplicationRecord
  after_commit :log_user_saved_to_db, on: :update

  private
    def log_user_saved_to_db
      Rails.logger.info("사용자가 데이터베이스에 저장되었습니다")
    end
end

irb> user = User.create
irb> User.transaction { user.save; user.save }
# User가 데이터베이스에 저장되었습니다

class PictureFile < ApplicationRecord
  after_commit :delete_picture_file_from_disk, on: :destroy

  def delete_picture_file_from_disk
    if File.exist?(filepath) 
      File.delete(filepath)
    end
  end 
end

class PictureFile < ApplicationRecord
  after_destroy_commit :delete_picture_file_from_disk

  def delete_picture_file_from_disk
    if File.exist?(filepath)
      File.delete(filepath) 
    end
  end
end

class User < ApplicationRecord
  after_create_commit :log_user_saved_to_db
  after_update_commit :log_user_saved_to_db

  private
    def log_user_saved_to_db
      # 이는 한 번만 호출됩니다
      Rails.logger.info("User was saved to database")
    end
end

irb> user = User.create # 출력 없음

irb> user.save # @user 업데이트
User was saved to database

class User < ApplicationRecord
  after_save_commit :log_user_saved_to_db

  private
    def log_user_saved_to_db
      Rails.logger.info("User가 데이터베이스에 저장되었습니다") 
    end
end

irb> user = User.create # User 생성하기 
User was saved to database

irb> user.save # user 업데이트하기
User was saved to database

class User < ActiveRecord::Base
  after_commit { Rails.logger.info("이것이 먼저 호출됩니다") }
  after_commit { Rails.logger.info("이것이 두 번째로 호출됩니다") }
end

config.active_record.run_after_transaction_callbacks_in_order_defined = false

class FileDestroyerCallback
  def after_commit(file)
    if File.exist?(file.filepath)
      File.delete(file.filepath)
    end
  end
end

class PictureFile < ApplicationRecord
  after_commit FileDestroyerCallback.new 
end

class FileDestroyerCallback
  def self.after_commit(file)
    if File.exist?(file.filepath)
      File.delete(file.filepath)
    end
  end
end

class PictureFile < ApplicationRecord
  after_commit FileDestroyerCallback
end