Ruby on Rails : RESTful 和 Ajax

Ruby on Rails
Part3: RESTful & Ajax
ihower@gmail.com

http://creativecommons.org/licenses/by-nc/2.5/tw/

Browser MVC
Model-View-Control
HTTP request
GET /users/1 route.rb

UsersController
Model
def show
@user = User.ﬁnd(params[:id])

respond_to do |format| Database
format.html
format.xml
end
end
#show.html.erb
View
<html>
def index
<h1>User Proﬁle</h1>
......
<p><%= @user.nickname %></p>
end
</html>
end

Browser Controller Action
MVC
Model-View-Control
HTTP request
GET /users/1 route.rb

UsersController
Model
def show
@user = User.ﬁnd(params[:id])

respond_to do |format| Database
format.html
format.xml
end
end
#show.html.erb
View
<html>
def index
<h1>User Proﬁle</h1>
......
<p><%= @user.nickname %></p>
end
</html>
end

Representational State Transfer
( REST)

• Roy Fielding 2000

• SOAP XML-RPC

• Web Service API
Amazon Yahoo! Google API

RESTful :

designing controller
and action is chaos

controller
class EventsController < ApplicationController

index
show
new
create
edit
update
destroy

controller

index watch_list
show add_favorite
new invite
create join
edit leave
update white_member_list
destroy black_member_list
feeds deny_user
add_comment allow_user
show_comment edit_managers
destroy_comment set_user_as_manager
edit_comment set_user_as_member
approve_comment .....
mark_comment_as_spam etc.

controller

index watch_list
show add_favorite
new
create controller ???
invite
join
edit
update
actions leave ????
white_member_list
destroy controller actions
black_member_list ???
feeds deny_user
add_comment allow_user
show_comment edit_managers
destroy_comment set_user_as_manager
edit_comment set_user_as_member
approve_comment .....
mark_comment_as_spam etc.

named routes
# routes.rb
map.connect '/:controller/:action/:id'

<%= link_to ‘text’, :controller => ‘events’,
:action => ‘show’,
:id => event.id %>

named routes
# routes.rb

:id => event.id %>

named route

named routes
# routes.rb

:id => event.id %>

named route
# routes.rb
map.event '/events/:id', :controller => 'event', :action => 'show'

named routes
# routes.rb

:id => event.id %>

named route
# routes.rb

<%= link_to ‘text’, event_path(event) %>

named routes
# routes.rb

hmm.... named routes
event_delete_path?
:id => event.id %>

event_create_path?
named route
events_path?
# routes.rb
events_new_path?

<%= link_to ‘text’, event_path(event) %>

HTTP methods (RFC 2616)

POST GET PUT DELETE

Create Read Update Delete

HTTP methods (RFC 2616)

POST GET PUT DELETE

Create Read Update Delete

GET is deﬁned as
a safe method

/events/create

/events/show/1

/events/update/1

/events/destroy/1

/events/create
Add
HTTP method
/events/show/1

/events/update/1

/events/destroy/1

/events/create POST /events
Add
HTTP method
/events/show/1 GET /events/1

/events/update/1 PUT /events/1

/events/destroy/1 DELETE /events/1

/events/create POST /events
Add
HTTP method
/events/show/1 GET /events/1

/events/update/1 PUT /events/1

/events/destroy/1 DELETE /events/1

Remove actions from URL, and
we have simple named route.

CRUD-based action names
get things simpler
create show update delete

POST GET PUT DELETE

CRUD-based action names
get things simpler
create show update delete

POST GET PUT DELETE

controller CRUD

routes.rb
ActionController::Routing::Routes.draw do |map|
map.resources :events
end

named routes actions

routes.rb
end

a resource is
something with URL


routes.rb
end

a resource is
something with URL

4

routes.rb
end

a resource is
something with URL

4 7

routes.rb
end

a resource is
something with URL

4 7
4 HTTP method

index The default
request method is
GET

<%= link_to ‘event list’, events_path %>


def index
@events = Event.find(:all)
end
...
end

show The default
request method is
GET

<%= link_to event.name, event_path(event) %>


def show
@event = Event.find(params[:id])
end
...
end

new/create
<%= link_to ‘new event’, new_event_path %>

def new
@event = Event.new
end
end

new/create

def new
@event = Event.new
end
end

<% form_for @event, :url => events_path do |f| %>
<%= f.text_field :name %>
<%= f.submit "Create" %>
<% end %>

new/create

def new In a form, the default
@event = Event.new request method is
end POST
end

<% end %>

new/create

def new In a form, the default
@event = Event.new request method is
end POST
end

<% end %>

def create
Event.create(params[:id])
end
end

edit/update
<%= link_to event.name, edit_event_path(event) %>

def edit
end
end

edit/update

def edit
end
end
<% form_for @event, :url => event_path(@event),
:method => :put do |f| %>
<% end %>

edit/update

def edit
end
end
<%= f.submit "Create" %> the request
<% end %> method is
PUT

edit/update

def edit
end
end
<%= f.submit "Create" %> the request
<% end %> method is
PUT
def create
Event.create(params[:event])
end
end

the request
destroy method is
DELETE

<%= link_to @event, event_path(@event), :method => :delete %>


def destroy
Event.find(params[:id]).destroy
end
...
end

4 HTTP methods, 4 URL helper, 7 actions

Helper GET POST PUT DELETE

/events/1 /events/1 /events/1
event_path(@event)
show update destroy

/events /events
events_path
index create

/events/1/edit
edit_event_path(@event)
edit

/events/new
new_events_path
new

Singular and Plural RESTful
Routes
• show, new, edit, destroy
• index, new, create

Routes
event_path(@event)

Routes
event_path(@event)
HTTP verb show, update, destroy

Routes
event_path(@event)

events_path

Routes
event_path(@event)

events_path
HTTP verb index, create

[custom route]_event[s]_path( event )

new, edit


?
new, edit
?


_path
? _url http://domain/
new, edit
?


_path
? _url http://domain/
new, edit
?


:method => GET | POST | PUT | DELETE

map.connect ':controller/:action/:id'

link_to event.name, :controller => ‘events’,
:action => :show , :id => event.id

link_to event.name, :controller => ‘events’,
:action => :show , :id => event.id

link_to event.name, event_path(event)

resources URL Helper

The PUT&DELETE Cheat
• PUT&DELETE method

• Rails _method

• Rails _method
<form id="edit_events_1" method="post" action="/events/1">
<input type="hidden" value="put" name="_method"/>
....
</form>

• Rails _method
<form id="edit_events_1" method="post" action="/events/1">
<input type="hidden" value="put" name="_method"/>
....
</form>

<a onclick="var f = document.createElement('form'); f.style.display = 'none';
this.parentNode.appendChild(f); f.method = 'POST'; f.action = this.href;var m =
document.createElement('input'); m.setAttribute('type', 'hidden'); m.setAttribute
('name', '_method'); m.setAttribute('value', 'delete'); f.appendChild(m);f.submit
();return false;" href="/events/1">Destroy</a>

The Problem
• HTML GET/POST HTML forms
PUT/DELETE

The Problem
PUT/DELETE

• XmlHttpRequest ( Ajax request)
GET/POST/PUT/DELETE/HEAD/OPTIONS

The Problem
PUT/DELETE


• Firefox/Safari

The Problem
PUT/DELETE


• Firefox/Safari

• Opera PUT/DELETE

The Problem
PUT/DELETE


• Firefox/Safari

• Opera PUT/DELETE

• IE DELETE !

As a Ruby On Rails special, Prototype also reacts
to other verbs (such as 'put' and 'delete' by
actually using 'post' and putting an extra
'_method' parameter with the originally
requested method in there.)

The type of request to make ("POST" or "GET"), default is
"GET". Note: Other HTTP request methods, such as PUT
Text
and DELETE, can also be used here, but they are not
supported by all browsers.

4 HTTP methods, 4 URL helper, 7 actions

Helper GET POST PUT DELETE

/events/1 /events/1 /events/1
event_path(@event)
show update destroy

/events /events
events_path
index create

/events/1/edit
edit_event_path(@event)
edit

/events/new
new_events_path
new

It’s beauty, but RESTful can handle the real & complex world ?

standardization on
action name
The heart of the Rails’s REST support is a technique for
creating bundles of named routes automatically

From Rails Way Chap.4

One Action, Multiple
Response Formats
def index
@users = User.find(:all)
respond_to do |format|
format.html # index.html.erb
format.xml { render :xml => @user.to_xml }
end
end

format.html
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
"http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
</head>
<body>
<p> ihower at 2008-01-19 </p>
</body>
</html>

format.html
<html>
<head>
</head>
<body>
<p> ihower at 2008-01-19 </p>
</body>
</html>

format.xml

format.html
<html>
<head>
</head>
<body>
<p> ihower at 2008-01-19 </p>
</body>
</html>

format.xml

<?xml version="1.0" encoding="UTF-8"?>
<user>
<created-at type="datetime">2008-01-19T09:55:32+08:00</created-at>
<id type="integer">2</id>
<name>ihower</name>
<updated-at type="datetime">2008-01-19T09:55:32+08:00</updated-at>
</user>

you don't need this!
def show_html
end

def show_xml
render :xml => @user.to_xml
end

def show_json
@user = User.find(:all)
render :json => @user.to_json
end

action

Don’t repeat yourself

formats
• format.html • format.csv
• format.xml • format.xls
• format.js • format.yaml
• format.json • format.txt
• format.atom • more....
• format.rss

http://registrano.com/events/5381ae/attendees


http://registrano.com/events/5381ae/attendees.csv


http://registrano.com/events/5381ae/attendees.csv

http://registrano.com/events/5381ae/attendees.xls

XML API
JSON API

( UI )

XML API
JSON API

( UI )
Adobe Flex

URL
http://localhost:3000/users.xml

template
<%= link_to ‘User List’, formatted_users_path(:xml) %>

<a href=”/users.xml”>User List</a>

HTTP request Headers
GET /users HTTP/1.1

Host: localhost:3000
User-Agent: Mozilla/5.0 (Macintosh; U; Intel Mac OS X; zh-TW; rv:1.8.1.13)
Gecko/20080311 Firefox/2.0.0.13
Accept: text/javascript, text/html, application/xml, text/xml, */*
Accept-Language: zh-tw,en-us;q=0.7,en;q=0.3
Accept-Encoding: gzip,deﬂate
Accept-Charset: Big5,utf-8;q=0.7,*;q=0.7
Keep-Alive: 300
Connection: keep-alive
X-Requested-With: XMLHttpRequest
X-Prototype-Version: 1.6.0.1

HTTP request Headers
GET /users HTTP/1.1

Host: localhost:3000
User-Agent: Mozilla/5.0 (Macintosh; U; Intel Mac OS X; zh-TW; rv:1.8.1.13)
Gecko/20080311 Firefox/2.0.0.13
Accept: text/javascript, text/html, application/xml, text/xml, */*
Accept-Language: zh-tw,en-us;q=0.7,en;q=0.3
Accept-Encoding: gzip,deﬂate
Accept-Charset: Big5,utf-8;q=0.7,*;q=0.7
Keep-Alive: 300
Connection: keep-alive Javascript Ajax
X-Requested-With: XMLHttpRequest request
X-Prototype-Version: 1.6.0.1

• params[:format]

GET /users/1?format=xml

• Controller code
class ApplicationController < ActionController::Base
before_ﬁlter :adjust_format_for_iphone
helper_method :iphone_user_agent?

protected

def adjust_format_for_iphone
request.format = :iphone if iphone_user_agent? || iphone_subdomain?
end
# Request from an iPhone or iPod touch?
# (Mobile Safari user agent)
def iphone_user_agent?
request.env["HTTP_USER_AGENT" ] &&
request.env["HTTP_USER_AGENT" ][/(Mobile/.+Safari)/]
end

def iphone_subdomain?
return request.subdomains.ﬁrst == "iphone"
end
end

custom format
# config/initializers/mime_types.rb
Mime::Type.register ‘audio/mpeg’, :mp3?Mime::Type.register ‘audio/mpegurl’, :m3u

custom format

def show
@mp3 = Mp3.find(params[:id])
format.html
format.mp3 { redirect_to @mp3.url }
format.m3u { render :text => @mp3.url }
end
end

custom format

http://localhost:3000/mp3s/1.mp3

def show
@mp3 = Mp3.find(params[:id])
format.html
format.mp3 { redirect_to @mp3.url }
format.m3u { render :text => @mp3.url }
end
end

template

• format (minetype) template generator
(renderer)
• Rails2 action.minetype.renderer
ﬁlename.html.erb

template
def index
format.html # index.html.erb
format.xml # index.xml.builder
end
end

erb template
• ruby code
• HTML ( format.html)
<h1><%= @event.name %></h1>

erb template
• ruby code

<h1>OSDC 2008</h1>

erb template
• ruby code

show.html.erb

<h1>OSDC 2008</h1>

builder template
• Ruby XML
xml.instruct!
xml.title "This is a title"
xml.person do
xml.first_name "Ryan"
xml.last_name "Raaum"
end

builder template
• Ruby XML
xml.instruct!
xml.person do
end

<title>This is a title</title>
<person>
<first_name>Ryan</first_name>
<last_name>Raaum</last_name>
</person>

builder template
• Ruby XML
xml.instruct!
xml.person do
end show.xml.builder

<title>This is a title</title>
<person>
<first_name>Ryan</first_name>
<last_name>Raaum</last_name>
</person>

builder template (cont.)
• Atom feed Rails2 Atom helper
atom_feed do |feed|
feed.title( @feed_title )
feed.updated((@events.first.created_at))
for event in @events
feed.entry(event) do |entry| index.atom.builder
entry.title(event.title)
entry.content(event.description, :type =>
'html')
entry.author do |author|
author.name( event.creator.nickname )
end
end
end
end

Ajax
link_to_remote ‘Terms’, :url => terms_path, :update => ‘content’

<a onclick="$.ajax({async:true, beforeSend:function(xhr) {xhr.setRequestHeader
('Accept', 'text/html, */*')}, complete:function(request){
$("#content").html(request.responseText);}, dataType:'html', type:'get', url:'/terms'});
return false;" href="/terms"> </a>

<div id=”content”> #content
Browser
</div>
HTML

<h1>ABC</j1>
Ajax format.html <ul>
<li>1</li>
<li>2</li>
</ul>

Server

Ajax

<a onclick="$.ajax({async:true, beforeSend:function(xhr) {xhr.setRequestHeader
('Accept', 'text/javascript, text/html, application/xml, text/xml, */*')}, dataType:'script',
type:'get', url:'/user/1'}); return false;>User</a>

<div id=”content”>
</div>
Javascript Browser

$("#content").html(ʻ blahʼ);
Ajax format.js $(“#sidebar”).html(ʻ blahʼ);
$("#content").effect("highlight");

Server

RJS template
<%= link_to_remote ‘ajax show’, :url => event_path(@event) %>

RJS template

def show
respond_to |format|
format.js
end
end

RJS template

def show

•
respond_to |format|
format.js
end
Ruby Javascript
end

RJS template

def show

•
respond_to |format|
format.js
end
Ruby Javascript
end

# show.js.rjs
page.replace_html ‘content’, :partial =>’event’
page.visual_effect :highlight, ‘ content’

RJS template

def show

•
respond_to |format|
format.js
end
Ruby Javascript
end

# show.js.rjs

try {
new Element.update("content", "blah");
new Effect.Highlight("content",{});
} catch (e) { alert('RJS error:nn' + e.toString()); alert('new Element.update
("content", "blah");nnew Effect.Highlight("content",{});'); throw e }

RJS template

def show

•
respond_to |format|
format.js
end
Ruby Javascript
end

# show.js.rjs

Browser Server
Javascript code
try {
new Element.update("content", "blah");
new Effect.Highlight("content",{});
} catch (e) { alert('RJS error:nn' + e.toString()); alert('new Element.update
("content", "blah");nnew Effect.Highlight("content",{});'); throw e }

inline RJS
def show
@note = Note.find(params[:id])
respond_to |format|
format.js {
render :update do |page|
page.replace_html ‘content’, :partial =>’note’
page << ‘alert(“hello world!”);’
end
}
end
end

inline RJS
def show
@note = Note.find(params[:id])
respond_to |format|
format.js {
page.replace_html ‘content’, :partial =>’note’
page << ‘alert(“hello world!”);’
end
}
end JavaScript
end

js.erb template
<%=link_to_remote ‘ajax’, :url => posts_path %>

def index
... • JavaScript
• Rails 1.x
respond_to |format|

end
format.js
hack!
end
(google MinusMOR plugin)

# index.js.erb
$j("#foo").html(<%= (render :partial => 'note.html').to_json %>);
$j("#foo").Highlight();

respond_to :
Graceful Degradation
def index
format.js {
page.replace_html ‘content’, ‘<p>blah</p>’
end
}
format.html #index.html.erb
end
end

<a href=”/users” onclick=”$.ajax(...blah...);return false;”>

respond_to :
def index
format.js {
end
}
end
end Browser Javascript


respond_to :
def index
format.js {
end
}
end
end Browser Javascript
Browser Javascript


Ajax

$.ajax({ async:true,
beforeSend:function(xhr) {xhr.setRequestHeader('Accept', 'text/xml, */*')}, type: “get”,
url: “/users”, dataType: “xml”, success: function(xml){
// js blah code
// js blah code

Browser
// js blah code
}); XML data
DOM

<data title=”title”>
Ajax format.xml <item>1</item>
<item>2</item>
<item>3</item>
</data>

Server

Ajax

$.ajax({ async:true,
beforeSend:function(xhr) {xhr.setRequestHeader('Accept', 'text/json, */*')}, type: “get”,
url: “/users”, dataType: “json”, success: function(json){
// js blah code
// js blah code

Browser
// js blah code
}); json data
DOM

[{"name": "aaaa", "updated_at":
"2008/01/19 09:55:32 +0800", "id": 2,
Ajax format.json "created_at": "2008/01/19 09:55:32
+0800"}, {"name": "bbbb222",
"updated_at": "2008/01/19 09:56:11
+0800", "id": 3, "created_at":
"2008/01/19 09:55:40 +0800"}]

Server

action
event has many attendees

Model design
class Event < ActiveRecord::Base
has_many :attendees
end

class Attendee < ActiveRecord::Base
belongs_to :event
end

nested resources(1) controller
attendees

map.resources :events do |event|
event.resources :attendees, :controller => 'event_attendees'
end

attendees

end

<%= link_to ‘event attendees’, event_attendees_path(@event) %>

attendees

end

/events/2/attendees


attendees

end

/events/2/attendees


class EventAttendeesController < ApplicationController

def index
@attendees = Event.find(params[:event_id]).attendees
end
...
end

nested resources(2)
<%= link_to ‘show’, event_attendees_path(@event,@attendee) %>

nested resources(2) /events/2/attendees/3





before_filter :find_event

def show
@attendees = @event.attendees.find(params[:id])
end

protected

def find_event
@event = Event.find(params[:event_id])
end
end





def show
end
Q: ??
protected Attendee.ﬁnd(params[:id])

def find_event
end
end





def show
end
Q: ??
protected Attendee.ﬁnd(params[:id])

def find_event
Ans:
end Scope Access
end

Deep Nesting?
Resources should never be nested more than one level deep.

Model design
class Event < ActiveRecord::Base
has_many :memberships
has_many :users, :through => :memberships
end

class User < ActiveRecord::Base
has_many :memberships
has_many :events, :through => :memberships
end

class Membership < ActiveRecord::Base
belongs_to :event
belongs_to :user
end

RESTful design 1

map.resources :memberships

RESTful design 1

map.resources :memberships

class MembershipsController < ApplicationController
# POST /memberships?group_id=2&user_id=1
def create end

# DELETE /memberships/3
def destroy end
end

RESTful design 2
map.resources :groups do |group|
group.resources :memberships
end

RESTful design 2
map.resources :groups do |group|
group.resources :memberships
end

class MembershipsController < ApplicationController
# POST /group/2/memberships/?user_id=1
def create end

# DELETE /group/2/memberships/3
def destroy end
end

singular resource route
• resources


• resource
event.resource :map, :controller => ‘event_maps’
end

singular resource route
• resources


• resource
event.resource :map, :controller => ‘event_maps’
end

RESTful controller

singular resource route (cont.)
• URL helper

• index action

• show, edit update URL Helper id

<%= link_to ‘Login’, event_map_path(@event) %>

<% form_for :event_map, :url => event_map_path(@event) do |f| %>

action
operate event state
(open/closed)

event.resource :closure, :controller => 'event_closures'
end

end

class EventClosuresController < ApplicationController

# POST /events/3/closure
def create
Event.find(params[:event_id]).close!
end

# DELETE /events/3/closure
def destroy
Event.find(params[:event_id]).open!
end

end

end


def create
end

def destroy
end

end

<%= link_to ‘close’, event_closure_path(@event), :method => :post %>

end


def create
end

def destroy
end

end

<%= link_to ‘close’, event_closure_path(@event), :method => :post %>
<%= link_to ‘open’, event_closure_path(@event), :method => :delete %>

why not
PUT closed=1 to /events/2
Text

why not
PUT closed=1 to /events/2
Text

“a separate resource” or “an attribute of event”

Extra Collection
Routes
map.resources :events, :collection => { :search => :get }

Extra Collection
Routes

def search
@events = Event.find_by_keyword(params[:keyword])
end
end

Extra Collection
Routes

def search
@events = Event.find_by_keyword(params[:keyword])
end
end

<%= link_to ‘search’, search_events_path, :keyword => ‘osdc’ %>

Extra Member Routes
map.resources :events, :member => { :dashboard => :get }

Extra Member Routes

def dashboard
end
end

Extra Member Routes

def dashboard
end
end

<%= link_to ‘dashboard’, dashboard_event_path(event) %>

Route Customizations
is not RESTful ??

is not RESTful ??

• you can think of it as a sub-resource of
events resource. (and the sub-resource has only one action)

is not RESTful ??

• you can think of it as a sub-resource of
events resource. (and the sub-resource has only one action)
• If you have too many extra routes, you
should consider another resources.

Use query variables
• Need not new resource
def index
sort_by = (params[:order] == ‘name’) ? ‘name’ : ‘created_at’
@events = Event.find(:all, :order => sort_by)
end

Use query variables
• Need not new resource
def index
sort_by = (params[:order] == ‘name’) ? ‘name’ : ‘created_at’
@events = Event.find(:all, :order => sort_by)
end

<%= link_to ‘search’, events_path, :order => ‘name’ %>

namespace
map.namespace :admin do |admin|
admin.resources :events
end

namespace
map.namespace :admin do |admin|
admin.resources :events
end

# /app/controllers/admin/events_controller.rb
class Admin::EventsController < ApplicationController
before_filter :require_admin

def index
....
end
end

Considerations(1)
• a REST resource does not map directly to
model. It’s high-level abstractions of what’s
available through your web app.
(Not always 1-to-1, maybe 1-to-many or 1-to-zero)

Considerations(1)
• a REST resource does not map directly to
model. It’s high-level abstractions of what’s
available through your web app.
(Not always 1-to-1, maybe 1-to-many or 1-to-zero)

• You don’t need to use all 7 actions if you
don’t need them.

map.resource :session
# This controller handles the login/logout function of the site.
class SessionsController < ApplicationController

def create
self.current_user = User.authenticate(params[:login], params[:password])
if logged_in?
redirect_back_or_default('/')
else
render :action => 'new'
end
end

def destroy
self.current_user.forget_me if logged_in?
cookies.delete :auth_token
reset_session
end
end

map.resource :session
# This controller handles the login/logout function of the site.
class SessionsController < ApplicationController

def create
self.current_user = User.authenticate(params[:login], params[:password])
if logged_in?
else
render :action => 'new'
end
end

def destroy
self.current_user.forget_me if logged_in?
cookies.delete :auth_token
reset_session
end
end
=> session

Considerations(2)

• a RESTful controller may represent the
creation or delete of only a concept.
For example, a SpamsController create spam by changing a comment’s status
to spam without adding any records to the DB.

Considerations(3)

• one resources should be associated with
one controller.
(well, you can use one controller handle more than one resources)

Considerations(3)

• one resources should be associated with
one controller.
(well, you can use one controller handle more than one resources)

• ofﬂoad privileged views into either a
different controller or action.

1 attendee Model
2 Resources related
(2 Controller)

map.resources :attendees

1 attendee Model
2 Resources related
(2 Controller)

map.resources :attendees class AttendeeController < ApplicationController

before_filter :manager_required

def show
@person = @event.attendees.find(params[:id])
end

end

1 attendee Model
2 Resources related
(2 Controller)

for event manager


def show
end

end

1 attendee Model
2 Resources related
(2 Controller)

for event manager


def show
end

end

map.resources :registers

1 attendee Model
2 Resources related
(2 Controller)

for event manager


def show
end

end


class RegistersController < ApplicationController
1 attendee Model before_filter :login_required

2 Resources related def show
@person = current_user.registers.find(params[:id])
(2 Controller) end

end

for event manager


def show
end

end


for attendeeing user
class RegistersController < ApplicationController
1 attendee Model before_filter :login_required

2 Resources related def show
@person = current_user.registers.find(params[:id])
(2 Controller) end

end

[namespace]_[custom route]_[parent resource]_event[s]_path( [p,] e)

new, edit
?

new, edit
nested
?

new, edit
nested ? ?
?

new, edit
nested ? ?
?

:method => GET | POST | PUT | DELETE

Nouns
URL

Verb
ﬁnite HTTP methods

URL without Nouns
action URL

Verb

URL without Nouns
action URL

Verb Content Types

URL without Nouns
action URL

Verb Content Types
ﬁnite HTTP methods HTML, XML, JSON....etc

URL without Nouns
the resource have
action URL many representations

Verb Content Types
ﬁnite HTTP methods HTML, XML, JSON....etc

Reference books:
• Rails Way(Addison Wesley)

• Advanced Rails (Pragmatic)

• Code Review PDF (peepcode.com)

• Rails2 PDF (peepcode.com)

• RESTful Web Services (O’REILLY)

Ruby on Rails : RESTful 和 Ajax

More Related Content

What's hot

Viewers also liked

Similar to Ruby on Rails : RESTful 和 Ajax

More from Wen-Tien Chang

Ruby on Rails : RESTful 和 Ajax