What Is Purpose of Around_Create Callback in Rails Model

Rails: around_* callbacks

around_* callbacks are invoked before the action, then when you want to invoke the action itself, you yield to it, then continue execution. That's why it's called around

The order goes like this: before, around, after.

So, a typical around_save would look like this:

def around_save
   #do something...
   yield #saves
   #do something else...
end

How to properly make a callback to create a model, after initialize of another model?

As prasannaboga already wrote in his comment. Callbacks like these are running in the context of an instance. That means you do not need to call a specific user first because the current object is already that user.

Additionally, in the context of a model, the redirect_to call doesn't make any sense. Models don't know anything about requests and responses. redirect_to is a controller method and you need to add it to your controller.

The following callback method should work:

def create_account
Account.create(owner_id: id, name: "#{name}'s Account")
end

I wonder why you decided to not add an has_one :account or has_many :accounts association to your User model? By doing so you could simplify the method even more because then Rails would handle setting the id automatically, like this

build_account(name: "#{name}'s Account")  # when `has_one` or
accounts.build(name: "#{name}'s Account") # when `has_many`

Ruby on Rails Callback, what is difference between :before_save and :before_create?

In a create operation under Rails, there are six callbacks before the database operation, and two after. In order, these are:

1. before_validation
2. before_validation_on_create
3. after_validation
4. after_validation_on_create
5. before_save
6. before_create
   DATABASE INSERT
7. after_create
8. after_save

Update operations have exactly the same set, except read update instead of create everywhere (and UPDATE instead of INSERT).

From this, you can see that validation is carried out before the before_save and before_create callbacks.

The before_save occurs slightly before the before_create. To the best of my knowledge, nothing happens between them; but before_save will also fire on Update operations, while before_create will only fire on Creates.

Difference between after_create, after_save and after_commit in rails callbacks

You almost got it right. However there is one major difference between after_commit and after_create or after_save i.e.

In the case of after_create, this will always be before the call to save (or create) returns.

Rails wraps every save inside a transaction and the before/after create callbacks run inside that transaction (a consequence of this is that if an exception is raised in an after_create the save will be rolled back). With after_commit, your code doesn't run until after the outermost transaction was committed. This could be the transaction rails created or one created by you (for example if you wanted to make several changes inside a single transaction). Originally posted here

That also means, that if after_commit raises an exception, then the transaction won't be rolled back.

From M-Dahab's comment:
after_commit would run after create, update and destroy. But, you can use on: option to specify which you are interested in. after_commit :some_method, on: :create or even after_commit :some_method, on: [:create, :destroy] or use a block like after_commit(on: :update) do run_method() end.

What is the difference between `after_create` and `after_save` and when to use which?

after_create only works once - just after the record is first created.

after_save works every time you save the object - even if you're just updating it many years later

So if you want to do this email operation only just the once (and then never again) then use after_create.

If you want to do it every time the object is saved, then do it in after_save

---

Related Topics