Question

I’d like to create a ‘timeline’ feature for an existing Card model. The Card already has_many Notes and has_many Attachments. I’d like to be able to:

• access notes, attachments (and other models eventually) in a unified collection with a nice method like: card.timeline
• still be able to access a card’s notes and attachments like: card.notes
• still be able to access a note’s parent card like: note.card
• be able to add items to the card’s timeline, with an API like: card.timeline << note

I think I have my DB set up correctly, it’s the association declaration I can’t seem to get right. Here’s my schema:

  create_table "cards", :force => true do |t|
    t.string   "name"
  end

  create_table "timeline_items", :force => true do |t|
    t.integer  "card_id",    :null => false # FK from cards table
    t.integer  "item_id",    :null => false # FK from notes or attachments table
    t.string   "item_type",  :null => false # either 'Note' or 'Attachment'
  end

  create_table "notes", :force => true do |t|
    t.text     "content"
  end

  create_table "attachments", :force => true do |t|
    t.string   "file_file_name"
  end

Anyone know how I can achieve this using ActiveRecord? It’s driving me fudging mental!

A starting point is:

class Card < ActiveRecord::Base
  has_many    :timeline_items
  has_many    :notes,       :through => :timeline_items, :source => :item, :source_type => 'Note', :order => 'updated_at DESC'
  has_many    :attachments, :through => :timeline_items, :source => :item, :source_type => 'Attachment', :order => 'updated_at DESC'
end

class TimelineItem < ActiveRecord::Base
  belongs_to :card
  belongs_to :item, :polymorphic => true
end

class Note < ActiveRecord::Base
  has_one     :card, :through => :timeline_items
  has_one     :timeline_item, :as => :item
end

Thanks in advance
~Stu

Answer 1

Okay – after struggling on and off with this, I crack it within 10mins of posting to stackoverflow! Typical.

To save others from banging their heads against walls, here’s what I had wrong:

Note should have been:

class Note < ActiveRecord::Base
  has_one     :card, :through => :timeline_item #not timeline_items
  has_one     :timeline_item, :as => :item
end

And that was it! I was trying to use the creation methods used in this article, but actually that’s not required.

Here’s the console output, showing that the sql statements are all using the timeline_items table:

1.9.2-p290 :009 > c = Card.find(547)
  Card Load (0.3ms)  SELECT `cards`.* FROM `cards` WHERE `cards`.`id` = 547 LIMIT 1
 => #<Card id: 547, name: "Duplicates appearing"> 

1.9.2-p290 :010 > c.notes.count
   (0.3ms)  SELECT COUNT(*) FROM `notes` INNER JOIN `timeline_items` ON `notes`.`id` = `timeline_items`.`item_id` WHERE `timeline_items`.`card_id` = 547 AND `timeline_items`.`item_type` = 'Note'
 => 4 

1.9.2-p290 :011 > c.notes.last.card
  Note Load (2.7ms)  SELECT `notes`.* FROM `notes` INNER JOIN `timeline_items` ON `notes`.`id` = `timeline_items`.`item_id` WHERE `timeline_items`.`card_id` = 547 AND `timeline_items`.`item_type` = 'Note' ORDER BY updated_at ASC LIMIT 1
  Card Load (3.2ms)  SELECT `cards`.* FROM `cards` INNER JOIN `timeline_items` ON `cards`.`id` = `timeline_items`.`card_id` WHERE `timeline_items`.`item_id` = 620 AND `timeline_items`.`item_type` = 'Note' LIMIT 1
 => #<Card id: 547, name: "Duplicates appearing"> 

1.9.2-p290 :013 > c.notes << Note.new(:content => 'Holee Sheeet Dawg', :user_id => 1)
   (0.2ms)  BEGIN
  SQL (0.6ms)  INSERT INTO `notes` (`content`, `created_at`, `updated_at`, `user_id`) VALUES ('Holee Sheeet Dawg', '2012-09-07 11:38:55', '2012-09-07 11:38:55', 1)
   (0.1ms)  COMMIT
   (0.1ms)  BEGIN
  SQL (0.3ms)  INSERT INTO `timeline_items` (`card_id`, `created_at`, `item_id`, `item_type`, `updated_at`) VALUES (547, '2012-09-07 11:38:55', 625, 'Note', '2012-09-07 11:38:55')
   (0.5ms)  COMMIT
  Note Load (1.8ms)  SELECT `notes`.* FROM `notes` INNER JOIN `timeline_items` ON `notes`.`id` = `timeline_items`.`item_id` WHERE `timeline_items`.`card_id` = 547 AND `timeline_items`.`item_type` = 'Note' ORDER BY updated_at DESC
 => [#<Note id: 625, content: "Holee Sheeet Dawg", user_id: 1, created_at: "2012-09-07 11:38:55", updated_at: "2012-09-07 11:38:55">, .....]

1.9.2-p290 :014 > c.notes.count
   (0.7ms)  SELECT COUNT(*) FROM `notes` INNER JOIN `timeline_items` ON `notes`.`id` = `timeline_items`.`item_id` WHERE `timeline_items`.`card_id` = 547 AND `timeline_items`.`item_type` = 'Note'
 => 5

EDIT:

I just noticed that my requirement of having card.timeline wasn’t met yet. Because the join is coming from multiple tables, I wasn’t able to get AR to handle the join for me (ideally *card.timeline_items.join(:notes, :attachments)* would have done the trick).

To solve this, I added the following method to my card class:

  def timeline
    (self.notes + self.attachments).sort { |a,b| a.updated_at <=> b.updated_at }
  end