Debugging Has_Many, Through Relationships in Ruby on Rails

Working with model associations can be difficult.

While building my mock Central Perk, Ruby on Rails application.

has_many

belongs_to

has_many through

Model Behavior

For my project, I planned on having three models: Users (baristas), Orders and Menu Items (products). A user could have many orders. An order, which belongs to a user, could have many Menu Items

With those models, programmatically, I wanted to be able to do the following:

• Create a new Order and automatically associate it with a User.

  shannon.orders.create

• Be able to see all orders that belong to a User.

  shannon.orders

• See all MenuItems (products) in a specific order.

  order.menu_items

After setting up my models, everything seemed to be working up until

order.menu_items

menu_items

Ross and Rachel looking confused

This is where a

has many through

Many to Many

If I wanted more than one MenuItem, per Order, the result of

order.menu_items

OrderItem

OrderItem

Order

MenuItems

Order

MenuItem

An Order would essentially be a collection of all

OrderItem

order_id

But?

At first, an

OrderItem

Until, it didn’t.

Would I need to call

order.order_items.menu_items

User

Pheobe running around screaming "What do I do?"

In reality, has_many through only works with three models. But, through other associations, it extends the functionality of those models. If I wanted to know how many MenuItems were in the first order, created by a specific user I could call something like this:

user.orders.first.menu_items.count

Visually, I thought of the relationships between the four models as looking like this:

Visualization of the has_many through relationship of User, Order (which contains OrderItems) and Menu Items

This was making sense!

I would not need to reference

OrderItems

Order

OrderItems

Order

MenuItems

My finalized models now looked like this:

class User < ApplicationRecord
  has_secure_password
  has_many :orders
end

class Order < ApplicationRecord
  belongs_to :user
  has_many :order_items
  has_many :menu_items, through: :order_items
end

class OrderItem < ApplicationRecord
  belongs_to :order
  belongs_to :menu_item
end

class MenuItem < ApplicationRecord
  has_many :order_items
  has_many :orders, through: :order_items
end

Params

With the associations complete, I needed a form to create the

Order

I noticed the

:menu_items_id

:menu_items_ids

To try and resolve this, I worked in the console, testing things out, bit by bit until I could pinpoint where I was getting stuck. In the console, I could successfully do the following.

• Create an order.

  order = Order.create(user_id: 1, name_for_pickup: "Rachel", menu_item_ids: [1,2,3])

• View the value of menu_items on an order.

  order.menu_items // [1,2,3]

• Add an item to an order.

  order.menu_items << item

• Save the order.

  order.save

Then it hit me.

Rails was right in not permitting the

menu_item_ids

find the menu items by id (menu_items_id, which was the unpermitted param) and shovel them into the array

I updated my create order method from this:

def create
  @order = Order.create(order_params)
  if @order.save
    redirect_to order_path(@order)
  else
    render :new
  end
end

To this

def create
  @order = Order.create(order_params)

  items_to_add = params[:order][:menu_item_ids]

  items_to_add.each do |item_id|
    if item_id != ""
      item_id = item_id.to_i
      item_to_add = MenuItem.find_by_id(item_id)
      @order.menu_items << item_to_add
    end
  end

  if @order.save
    redirect_to order_path(@order)
  else
    render :new
  end

end

And it worked!

Chandler jumping on a coffee table and doing a happy dance

Lessons Learned

In summary, if you are running into issues with object relationships, try the following:

Verify that the params are correct

Typos can instantly cause object creation to fail. Pluralization like

menu_item_id

menu_item_ids

All model attributes are listed in strong params

Strong params help to prevent users from injecting harmful data into your database via the form. If strong params lists only

:name

:email

:password

User

:not_a_hacker

Use .create! when testing

create!

Order

User

Order.create()

Order.create!()

Append `.valid?` to objects

An object may be updating, but, is it saving properly to the database? For example, if

order = Order.create()

:user_id

.valid?

Summary

Model associations can be difficult and frustrating, but not impossible to work with. With some careful debugging, you can be a master of model associations in no time.

Resources

• What Are Rails Parameters & How to Use Them Correctly
• Active Record Associations

Photo by Annie Spratt on Unsplash

Previously published at https://shannoncrabill.com/blog/ruby-on-rails-debugging-model-associations/