Day 11 : #100DaysofCode - RESTful Routes

Song of the day

The Internet

HTTP

HTTP stands for The Hypertext Transfer Protocol and it helps clients (aka browsers such as Chrome/Safari/Internet explorer) to communicate with a server. A browser sends an HTTP request to a server and then the server provides a response/status back.

HTTP Verbs

There are most common HTTP verbs/request you will see are:

GET	This request is used to GET information from the server using the url inputted. Request using GET can only retrieve data.
POST	This request is used to send (post) data to the server, usually by submitting a form.
PUT	This request uses the url to supply a modified version of the requested resource which replaces the original version of the resource (it is used to update information by replacing the original content)
PATCH	This request supplies a set of instructions to modify the resource. It is similar to a PUTS request in that it updates the information and should only be used if the patch document is smaller than the size of the new version of the source sent.
DELETE	This request does exactly what it is named, it removes the information of the target resource.

Now that we have a basic understanding on how request are made to the internet we can review restful routes.

A RESTful route is a route that provides mapping between HTTP verbs (get, post, put, delete, patch) to controller CRUD actions (create, read, update, delete). Instead of relying solely on the URL to indicate what site to visit, a RESTful route also depends on the HTTP verb and the URL.

WHATTTTTTT does that mean?

That means that when get a request it determines if it is a GET, POST, PATCH, PUT, or DELETE request and locates the url for it. Then it connects to the controller handling that action and url. It will then execute the code in that controller and determine what to send back to the user.

HTTP VERB	ROUTE	Action	Used For
GET	'/posts'	index action	index page to display all posts
GET	'/posts/new'	new action	displays create post form
POST	'/posts'	create action	creates one post
GET	'/posts/:id'	show action	displays one post based on ID in the url
GET	'/posts/:id/edit'	edit action	displays edit form based on ID in the url
PATCH	'/posts/:id'	update action	modifies an existing post based on ID in the url
PUT	'/posts/:id'	update action	replaces an existing article based on ID in the url
DELETE	'/posts/:id'	delete action	deletes one post based on ID in the url

#in your application controller
get '/posts' do
    @posts = Post.all
    erb :'/posts/index'
  end

The above getting a variable @posts to all of the posts you created in your database and rendering the /posts/index page with that information. @posts will now be available on your posts/index page as a variable that you can use to iterate over and display on the page.

#in your application controller
  get '/posts/new' do
    erb :'/posts/new'
  end

The above renders the /posts/new page so that the user can fill out a form which will look similar to this:

#in your views/posts/new
<form action="/posts" method="POST" >
  <input type="text" name="content" placeholder="content"><br/>
  <input type="submit" value="Create">
</form>

The form is making a POST request with the params named "content" that you can use to create a new post, like this:

#in your application controller
  post '/posts' do
    Post.create(content: params[:content])
    redirect '/posts'
  end

To make a patch/put request you will need to find the item that you are trying to edit and then use a form to make updates and make the patch/puts request.

You would find the item that you are trying to edit by using the .find method mentioned in a past post, like this:

#in your application controller
  get '/posts/:id/edit' do
    @post = Post.find(params[:id])
    erb :'/posts/edit'
  end

In a past post I mentioned that Ruby forms do not allow a user to make patch, delete, or puts request and that we must require Rack::MethodOverride in our config.ru. What I meant by that is that when you make a request, it requires an extra step, to make the application believe that it is making a POST request when really it is making a patch, put, or delete request. For example, our edit form will look like this:

<form action="/posts/<%= @post.id %>" method="post">
  <input id="hidden" type="hidden" name="_method" value="patch">
  <input type="text" name="content" value= "<%=@post.content %>">
  <input type="submit" value="update"/>
</form>

Rack::MethodOverride is like a Ruby helper that allows us to hide the patch method under the post method so that we can make that request.

Now to make the patch request in the application controller we would do the following.

#in your application controller
  patch '/posts/:id' do
   @post = Post.find(params[:id])
   @post.update(content: params[:content])
   redirect '/posts'
 end

Lastly, to make a delete request we would provide the following:

#in your views/posts/edit
<form action="/posts/<%= @post.id %>" method="post">
  <input id="hidden" type="hidden" name="_method" value="delete">
  <input type="submit" value="update"/>
</form>

#in your application controller
 delete '/posts/:id' do
  Post.destroy(params[:id])
  redirect to '/posts'
end

Resources:
w3schools

Mozilla Developer

Wiki

Check out my #100DaysofCode Github Repo