Day 11 : #100DaysofCode - RESTful Routes
Tags: ruby, codenewbie, 100daysofcode, womenintech
Published: 2020-06-12 03:03:40

<a href="https://soundcloud.com/user-615990366/are-we"> Song of the day </a>

<center><h1> The Internet </h1></center>
<h3> HTTP </h3>

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. 

<h3> HTTP Verbs </h3>

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

<table>
  <tr>
    <th> GET </th>
    <td> This request is used to <b>GET</b> information from the server using the url inputted. Request using <b>GET</b> can only retrieve data. </td>
  </tr>
<tr>
    <th> POST </th>
    <td>This request is used to send (post) data to the server, usually by submitting a form.</td>
  </tr>
<tr>
    <th> PUT </th>
    <td> 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) </td>
  </tr>
<tr>
    <th> PATCH </th>
    <td> 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. 
     </td>
  </tr>
<tr>
    <th> DELETE </th>
    <td>This request does exactly what it is named, it removes the information of the target resource.</td>
  </tr>
</table>

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

<q>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.</q>

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 <a href="https://dev.to/sincerelybrittany/day-9-100daysofcode-activerecord-and-a-database-6de"> post</a>, 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 <a href="https://dev.to/sincerelybrittany/day-6-100daysofcode-sinatra-set-up-part-2-config-ru-h4b">Rack::MethodOverride</a> 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>
```

<a href="https://www.rubydoc.info/github/rack/rack/Rack/MethodOverride"> Rack::MethodOverride </a> 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:
<a href="https://www.w3schools.com/tags/ref_httpmethods.asp#:~:text=The%20GET%20Method,%2Ftest%2Fdemo_form.php%3F"> w3schools </a>

<a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods"> Mozilla Developer </a>

<a href="https://en.wikipedia.org/wiki/Patch_verb#:~:text=The%20main%20difference%20between%20the,instructions%20to%20modify%20the%20resource."> Wiki </a>

Check out my <a href="https://github.com/SincerelyBrittany/100DaysofCode"> #100DaysofCode Github Repo </a>