text:
# Node.js - Aula 02 - Exercício
autor: Igor Vidotto Felipe

#### 1 - Quais são os 4 verbos que utilizamos para o CRUD?

* POST
* GET
* PUT
* DELETE

#### 2 - Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do Cat Status Code.
Os *Status Codes*, também chamados de [*Response Codes*](https://developer.mozilla.org/en-US/docs/Web/HTTP), foram criados para responder uma requisição do cliente. O servidor envia um número de três dígitos se a requisição foi processada corretamente, sendo que esse número é determinado pelo estado do servidor mediante a requisição realizada.

#### 1XX Informacional

###### 100 - Continue
Essa resposta provisória indica que tudo até agora está OK e que o cliente deve continuar com a requisição ou apenas ignorar, se sua requisição já foi finalizada.

![Status Code 100](https://http.cat/100)

#### 2XX Sucesso

###### 201 - Created
A requisição foi realizada com sucesso e um novo recurso foi criado como resultado. Esta é uma resposta enviada tipicamente após uma requisição de *PUT*.

![Status Code 201](https://http.cat/201)

#### 3XX Redirecionamento

###### 304 - Not Modified
Se o cliente executou uma requisição de condição *GET* e o acesso é permitido, mas o documento não foi modificado, o servidor deve responder com o mesmo status code. A resposta 304 não deve conter uma *message-body*, e deste modo é sempre terminada pela primeira linha vazia após os campos do *header*.

![Status Code 304](https://http.cat/304)

#### 4XX Erro do Cliente

###### 400 - Bad Request
A requisição não foi entendida pelo servidor devido a sintaxe mal estruturada. O cliente não deve repetir a requisição sem antes modificá-la.

![Status Code 400](https://http.cat/400)

#### 5XX Erro de Servidor

###### 502 - Bad Gateway
O servidor, enquanto agindo como um *gateway* ou *proxy*, recebeu uma resposta inválida do servidor *upstream* que acessou na tentativa de completar a requisição.

![Status Code 502](https://http.cat/502)

#### 3 - Explique o que é cada parâmetro da função recebida no `createServer`.
Essa função é uma função de *callback* que recebe dois parâmetros: **request**, que é o parâmetro que contém a requisição do cliente e **response**, que o servidor utiliza para providenciar a resposta de acordo com a requisição do cliente.

#### 4 - O que é e para que serve a Querystring?
São as variáveis e valores que são obtidos através de formulários ou requisições do usuário e que são enviados à **url**, como `?name=Igor`, por exemplo. No Node.js, existe um módulo nativo chamado `url`, que é responsável por fazer *parser* e formatação de urls.

A função `url.parse()` retorna um objeto com vários atributos da url, dentre eles o atributo **query** que é o responsável por retornar a **query string** em formato JSON.

#### 5 - Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
* /api/pokemons/create
* /api/pokemons/read
* /api/pokemons/update
* /api/pokemons/delete

```js
// server.js

'use strict';

var date = (new Date()).toJSON();

var http = require('http')
  , url = require('url')
  , SUCESS =
    { version: '1.0'
    , name: 'Exercício 02 Node.js'
    , returned_at: date
    }
  ;

http.createServer(function(request, response){
  var pathname = url.parse(request.url).pathname
    , routes =
      [ '/api/pokemons/create'
      , '/api/pokemons/read'
      , '/api/pokemons/update'
      , '/api/pokemons/delete'
      ]
    ;

  for(var key in routes){
    if (routes[key] === pathname) {
      response.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
      response.write(JSON.stringify(SUCESS));
    }
  }

  response.end();

}).listen(3000, function(){
  console.log('Servidor rodando em localhost:3000');
});
```


text:
# NodeJS - Aula 02 - Exercício
**User:** [daniofilho](https://github.com/daniofilho)

**Autor:** Dânio Filho

**Date:** 1452553737957

## Quais são os 4 verbos que utilizamos para o CRUD?

Os principais métodos/verbos são:

- POST
- GET
- PUT
- DELETE

## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).

Os Status Codes são códigos de 3 digitos que seguem um certo padrão e que são retornados para especificar qual foi o resultado de uma requisição.

### 1XX - Informacional ###

Mostra que a informação recebida está sendo processada. Não diz que finalizou ou quando o fará, apenas mostra que está em processo.

Exemplo:

![](https://http.cat/101)

### 2XX - Sucesso ###

Avisa que a requisição foi processada com sucesso. Esta á a informação padrão que se recebe ao carregar um site, por exemplo.

Exemplo:

![](https://http.cat/202)

### 3XX - Redirecionamento ###

Retorna a informação de que aquela url especificada foi movida para outro local.

Exemplo:

![](https://http.cat/301)

### 4XX - Erro do cliente ###

Informa que houve algum problema na requisição, mas foi causado pelo lado do cliente.

Exemplo:

![](https://http.cat/404)

### 5XX - Erro do servidor ###

Informa que houve algum problema na requisição, mas foi causado pelo lado do servidor.

Exemplo:

![](https://http.cat/509)

## Explique o que é cada parâmetro da função recebida no `createServer`.

O **request** exibe as informações da requisição feita pelo cliente/usuário e o **response** é o retorno que ele receberá.

## O que é e para que serve a Querystring?

São parâmetros que são enviados junto com a URL via GET. Esses parâmetros seguem o padrão de `'key': 'value'` e servem para requisitar algo para o servidor.

## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:

~~~ js
'use strict';

var date = (new Date()).toJSON();

const http = require('http'),
      SUCCESS = {
         version: 1.1,
         code: 200,
         name: 'Be MEAN',
         created_at: date
      },
      ERROR = {
         message: "Não encontrado!"
      };

http.createServer(function(req, res){

   let url = req.url;

   switch(url){

      case "/api/pokemons/create":
         create();
         break;

      case "/api/pokemons/read":
         read();
         break;

      case "/api/pokemons/update":
         update();
         break;

      case "/api/pokemons/delete":
         delete();
         break;

      default:
         res.writeHead(404, { 'Content-Type': 'application/json;' });
         res.write(JSON.stringify(ERROR));
         break;
   }

   res.end();

}).listen(3000, function(){
    console.log('Servidor rodando em localhost:3000');
});

function create(){
   res.writeHead(200, { 'Content-Type': 'application/json;' });
   res.write(JSON.stringify(SUCCESS));
}

function read(){
   res.writeHead(200, { 'Content-Type': 'application/json;' });
   res.write(JSON.stringify(SUCCESS));
}

function update(){
   res.writeHead(200, { 'Content-Type': 'application/json;' });
   res.write(JSON.stringify(SUCCESS));
}

function delete(){
   res.writeHead(200, { 'Content-Type': 'application/json;' });
   res.write(JSON.stringify(SUCCESS));
}

~~~

repo_language: JavaScript

mime_type: text/plain


text:
# Node.js - Aula 02 - Exercício
**user:** [Rafael Jourdan](https://github.com/rafaeljourdan)

**autor:** Rafael Jourdan

**date:** 09/01/2017

## Quais são os 4 verbos que utilizamos para o CRUD?
* POST
* GET
* PUT
* DELETE

## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
As `Status Codes` foram criadas para responder uma requisição do cliente

**1XX: Servidor recebeu cabeçalhos**
!['100'](https://http.cat/100)

**2XX: Resposta OK do servidor, tudo OK**
!['200'](https://http.cat/200)

**3XX: Redirecionamento temporário**
!['300'](https://http.cat/307)

**4XX: Recurso não encontrado (Erro usuário)**
!['404'](https://http.cat/404)

**5xx: Erro interno no servidor**
!['500'](https://http.cat/500)

## Explique o que é cada parâmetro da função recebida no `createServer`.
* Request: Requisição que contém a solicitação do cliente: cabeçalhos, campos, parâmetros query string, etc.
* Response: Utilizado para devolver dados de volta para o cliente.

## O que é e para que serve a Querystring?
Parâmetros enviados via URL ou FORMULÁRIO com method='get'
`?var1=1&var2=true&var3=teste`
```
    <form action="/salvar" method="get">
        <input type="text" name="nome" />
        <input type="submit" value="salvar" />
    </form>
```

## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:

```js
'use strict';

const http = require('http');
const apiVersion = '/api/v1';

var server = http.createServer(function(req,res){

    res.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});

    switch(req.url){
        case apiVersion + '/create':
            retornoJson(res, 'rota create');
            break;
        case apiVersion + '/read':
            retornoJson(res, 'rota read');
            break;
        case apiVersion + '/update':
            retornoJson(res, 'rota update');
            break;
        case apiVersion + '/delete':
            retornoJson(res, 'rota delete');
            break;
        default:
            res.writeHead(404, {'Content-Type': 'application/json;charset=utf-8'});
            retornoJson(res, 'ERRO: Rota não encontrada ou não autorizado.');
            break;
    }
    res.end();
});

server.listen(3000, function(){
    console.log('Servidor levantando na 3000');
});

function retornoJson(response, mensagem){
    var json = {
        'mensagem': mensagem,
        'data': new Date()
    };
    return response.write(JSON.stringify(json));
}
```


text:
# Node.js - Aula 02 - Exercício
**user:** [dayvsonsales]https://github.com/dayvsonsales
**autor:** Dayvson SAles

## Quais são os 4 verbos que utilizamos para o CRUD?

- Create - POST
- Retrieve/Read - GET
- Update - PUT
- Delete - DELETE

## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).

Padronizar o retorno das requisições HTTP. Facilitando o entendimento por meio dos clients/bots.

100 - Continue - https://http.cat/100
200 - OK  - https://http.cat/200
301 - Movido permanentemente - https://http.cat/301
404 - Not found - https://http.cat/404
500 - Erro interno no servidor - https://http.cat/500

## Explique o que é cada parâmetro da função recebida no `createServer`.

Request - variável de acesso aos parâmetros de requisição pelo client
Response - variável que possui metódos para envio de resposta ao client

## O que é e para que serve a Querystring?

Padrão do protocolo HTTP para enviar informações através de requisições.

Por exemplo:

http://exemplo.com/?tipo=1&codigo=104

## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:

```
(...)

const SUCCESS = {
		error: false, data: "", msg: ""
	},
	ERROR = { error: true, msg: "Not found"}
;

var server = http.createServer(function(request, response){
		switch(request.url){
			case "/" :
				response.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
				response.end(index);
			break;
			case "/api/pokemons/create" :
				response.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
				response.end(JSON.stringify({error: false, msg: "Inserido com sucesso!", data: {name: "pokemon"}}));
			break;
			case "/api/pokemons/update" :
				response.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
				response.end(JSON.stringify({error: false, msg: "Atualizado com sucesso!", data: {name: "pokemon"}}));
			break;
			case "/api/pokemons/read" :
				response.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
				response.end(JSON.stringify({error: false, data: {name: "pokemon"}}));
			break;
			case "/api/pokemons/delete" :
				response.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
				response.end(JSON.stringify({error: false, msg: "Excluido com sucesso!"}));
			break;
			default:
				response.writeHead(404, {'Content-Type' : 'application/json; charset=utf-8'})
				response.end(JSON.stringify(ERROR));
			break;
		}
});
(...)
```


text:
# NodeJS - Aula 02 - Exercício
**Autor:** Rafael Crispim Ignácio

**Data** 1451226657631

# 1. Quais são os 4 verbos que utilizamos para o CRUD?

```js
- Create - POST
- Retrieve/Read - GET
- Update - PUT
- Delete - DELETE
```

# 2. Para que foram inventados os Status Codes? Dê um exemplo de 1 código por grupo e a imagem do Cat Status Code
Os `Status Codes` foram criados para identificarmos como uma requisição foi recebida pelo servidor.

```
101 - Switching protocols
```

![Image 101](https://http.cat/101)

```
200 - OK
```

![Image 200](https://http.cat/200)

```
301 - Moved Permanently
```

![Image 301](https://http.cat/301)

```
404 - Not Found
```

![Image 404](https://http.cat/404)

```
500 - Internal Server Error
```

![Image 500](https://http.cat/500)

# 3. Explique o que é cada parâmetro da função recebida no 'createServer'.

```js
function(request, response) {
    ...
}
```

- request

Representa a requisição recebida, ela contém os dados presentes no client. É deste parâmetro que capturamos as querystrings para processar uma busca ou autenticação. Também é possível verificar os headers recebidos assim como algumas outras configurações.
- response

Representa a resposta que será devolvida ao usuário. Neste parametro temos acesso as configurações do documento através dos headers e do conteúdo que será exibido. Este parâmetro é o que controla o que será retornado ao cliente ao fim de uma requisição.

# 4. O que é e para que serve a Querystring?

```
Querystring é a maneira que temos para transitar informações utilizando o protocolo http. Desta maneira podemos enviar parâmetros para o servidor para serem processados, como por exemplo uma busca ou uma autenticação.
```

# 5. Escreva no código do 'server.js' uma forma de entregar um JSON de sucesso em 4 rotas diferentes:

```js
'use strict';

var date = (new Date()).toJSON();

const http = require('http')
    , SUCCESS = {
        version: '1.0',
        name: 'Be MEAN',
        returned_at: date
    }
    , ERROR = {
        message: "Não encontrado!"
    };

http.createServer(function(request, response){
    switch (request.url) {
        case '/api/pokemons/create':
        case '/api/pokemons/read':
        case '/api/pokemons/update':
        case '/api/pokemons/delete':
            response.writeHead(200, {'Content-Type': 'text/html; charset=utf-8'});
            response.write(JSON.stringify(SUCESS));
            break;
        default:
            response.writeHead(404, {'Content-Type': 'text/html; charset=utf-8'});
            response.write(JSON.stringify(ERROR));
    }

    response.end();
}).listen(3000, function(){
    console.log('localhost:3000');
});
```


text:
# Node.js - Aula 02 - Exercício

**user:** [jeffersondanielss](https://github.com/jeffersondanielss)

**autor:** Jefferson Daniel Santos Silva

## Quais são os 4 verbos que utilizamos para o CRUD?
+ CREATE
+ RETRIVE/READ
+ UPDATE
+ DELETE

## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).

##### 100
Quando o servidor recebeu os cabeçalhos da solicitação.
![100](https://http.cat/100.jpg)

##### 200
O modelo de resposta para solicitações http de sucesso.
![200](https://http.cat/200.jpg)

##### 404
Indica que o recurso requisitado não foi encontrado.
![404](https://http.cat/404.jpg)

##### 503
O servidor está em manutenção ou não consegue dar conta dos processamentos de recursos.
![503](https://http.cat/503.jpg)

## Explique o que é cada parâmetro da função recebida no `createServer`.
request: O objeto de solicitação contém informações sobre a solicitação do cliente, tais como a URL, cabeçalhos HTTP, e muito mais.

response: Utilizado para devolver dados de volta para o cliente.

## O que é e para que serve a Querystring?
A querystring é um conjunto de parametros passados para o browser que é enviado para um programa de consulta e serve para recuperar informações específicas a partir de um banco de dados.

## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:

```
  'use strict';

  var date = (new Date()).toJSON();

    const http = require('http')
        , SUCCESS = {
            version: '1.0'
          , name: 'Be MEAN'
          , returned_at: date
          }
        , ERROR = {
          message: 'Não encontrado'
        }

  http.createServer(function( req, res ){

    function success() {
      res.writeHead(200, {'Content-Type': 'application/json'});
      res.write(JSON.stringify(SUCCESS));
    }

    switch(req.url) {
      case '/api/pokemons/create':
        success();
        break;

      case '/api/pokemons/read':
        success();
        break;

      case '/api/pokemons/update':
        success();
        break;

      case '/api/pokemons/delete':
        success();
        break;

      default:
        res.writeHead(400, {'Content-Type': 'application/json; charset=utf-8'});
        res.write(JSON.stringify(ERROR));
        break;
    }

    res.end();
  }).listen(3000, function(){
    console.log( 'Servidor rodando em localhost:3000' )
  });
```


text:
# NodeJS - Aula 02 - Exercício
autor: Wellerson Roberto

## 1) Quais são os 4 verbos que utilizamos para o CRUD?

Create - POST

Read - GET

Update - PUT

Delete - DELETE

## 2) Para que foram inventados os Status Codes? Dê exemplo de um código por grupo e a imagem do Cat Status Code.

Foi inventado para o servidor informar, de maneira padronizada, se sua requisição foi atentidada ou não e o por que.

101 -> Trocando protocolos. O socilicitante pediu ao servidor para mudar os protocolos e o servidor irá fazê-lo. [Http.cat](https://http.cat/101)

204 -> Sem conteúdo. O servidor processou a requisição corretamente, mas não retornou nenhum conteúdo. [Http.cat](https://http.cat/204)

301 -> Movido permanentemente. Esta e todas as futuras requisições foram movidas permanentemente. [Http.cat](https://http.cat/301)

414 -> URI muito longa para o servidor processar. [Http.cat](https://http.cat/414)

508 -> Loop detectado. O servidor detectou um loop infinito enquanto processava a requisição. [Http.cat](https://http.cat/508)

## 3) Explique o quê é cada parâmetro da função recebida no 'createServer'

São passados dois parâmetros para a função recebida no createServer. O primeiro, normalmente chamado de **request** ou apenas **req**, é uma instância de **http.IncomingMessage** e é um objeto que possui informações acerca da requisição que foi feita. Nele você pode obter, por exemplo, o cabeçalho da requisição, o verbo/método, a url, a versão do HTTP... Já o segundo parâmetro, normalmente chamado de **response** ou apenas **res**, é uma instância de **http.ServerResponse**, sendo responsável por manipular a resposta que será enviada para o cliente. Ao enviar uma informação para o cliente, por exemplo, o objeto **response** será acionado, através de seus métodos **write**, **writeHead** e **end**.

## 4) O quê é e para que serve o Query String?

O **Query String** é parte de uma URL que pode conter dados que serão enviados ao servidor em um formato de chave/valor. Serve basicamente para enviar dados ao servidor. É também muito usado em APIS Web, para enviar dados que serão usados numa consulta, como por exemplo o formato que você quer recuperar uma informação.

```
http://example.com/geoserver/wfs?service=wfs&version=1.1.0&request=GetCapabilities
```

A Query String inicia-se após o **?** de uma URL. Depois, cada campo segue a estrutura "campo = valor", sem aspas mesmo para os campos de texto. Na URL acima, a Query String possui 3 campos/valores.

```
campo -> valor
service -> wfs
version -> 1.1.0
request -> GetCapabilities
```

## 5) Escreva no código do "server.js" uma forma de entregar um JSON de sucesso em 4 rotas diferentes

```
'use strict';

const http = require('http')
    , date = new Date().toJSON()
    , SUCCESS = {
        version: 1,
        name: 'Be Mean',
        date: date
    },
    ERROR = {
        message: "Não encontrado!"
    };

http.createServer(function (req, response) {
    switch(req.url){
        case "/api/pokemons/create":
        case "/api/pokemons/read":
        case "/api/pokemons/update":
        case "/api/pokemons/delete":
            response.writeHead(200, { 'Content-Type': 'application/json' });
            response.write(JSON.stringify(SUCCESS));
            break;
        default:
            response.writeHead(404, { 'Content-Type': 'application/json;charset=utf-8' });
            response.write(JSON.stringify(ERROR));
    }
    response.end();
}).listen(3000, function () {
    console.log('Estou pronto!');
});
```


text:
# Node.js - Aula 02 - Exercício
**user:** charles7421
**autor:** Charles de Freitas Garcia

## Quais são os 4 verbos que utilizamos para o CRUD?

* CREATE
* READ
* UPDATE
* DELETE

## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).

* São códigos de retorno HTTP, para padronizar a identificação oo retorno das requisições. São formados por 3 dígitos, com o primeiro digito, sendo o de identificação do tipo.
  * 1XX - Informativos
   ** 100 - Continuar

	![](https://http.cat/100)

  * 2XX - Sucesso
   ** 200 - OK

   ![](https://http.cat/200)

  * 3XX - Redirecionamento
   ** 302 - Encontrado

   ![](https://http.cat/302)

  * 4XX - Erro de Cliente
   ** 404 - Não encontrado

   ![](https://http.cat/404)

  * 5XX - Erro de Servidor
   ** 500 - Erro interno do servidor

   ![](https://http.cat/500)

## Explique o que é cada parâmetro da função recebida no `createServer`.

"http.createServer(function(request, response)"...

* Request : É a informação que chega ao servidor através do navegador.
* Response: É a resposta que deve chegar ao navegador através do servidor.

## O que é e para que serve a Querystring?

* QueryString é um conjunto de chave/valor e serve para passar paramêtros para servidor via URL.

## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:

```js
'use strict';

var date = (new Date()).toJSON();

const http = require('http')
  , SUCCESS = {
    version: '1.0'
      , name: 'Be Mean'
    , returned_at: date
  }
  , ERROR = {
    message: "Não encontrado."
  };

http.createServer(function(req, res) {
  switch(req.url) {
    case '/api/pokemons' + '/create':
      res.writeHead(200, { 'Content-Type' : 'application/json; charset=utf-8' });
      res.write(JSON.stringify(SUCCESS));
      break;
    case '/api/pokemons' + '/read'  :
      res.writeHead(200, { 'Content-Type' : 'application/json; charset=utf-8' });
      res.write(JSON.stringify(SUCCESS));
      break;
    case '/api/pokemons' + '/update':
    res.writeHead(200, { 'Content-Type' : 'application/json; charset=utf-8' });
      res.write(JSON.stringify(SUCCESS));
      break;
    case '/api/pokemons' + '/delete':
      res.writeHead(200, { 'Content-Type' : 'application/json; charset=utf-8' });
      res.write(JSON.stringify(SUCCESS));
      break;
    default:
      res.writeHead(404, { 'Content-Type' : 'application/json; charset=utf-8' });
      res.write(JSON.stringify(ERROR));
  }
  res.end();
}).listen(3000, function() {
  console.log('Servidor rodando em localhost:3000');
});


text:
# Node.js - Aula 02 - Exercício
**user:** [gpanassol](https://github.com/gpanassol)

**autor:** Gabriel Panassol

## Quais são os 4 verbos que utilizamos para o CRUD?

- GET
- PUT
- DELETE
- OPTIONS

## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).

O Status Codes foram inventados para apresentar ao usuário um codigo/mensagem identificando uma determinada situação do servidor. Os principais são:

## 1XX - Informacional
![100](https://http.cat/100)

## 2XX - Sucesso
![200](https://http.cat/200)

## 3XX - Redirecionamento
![303](https://http.cat/303)

## 4XX- Erro de cliente
![403](https://http.cat/403)

## 5XX - Erro de servidor
![500](https://http.cat/500)

## Explique o que é cada parâmetro da função recebida no `createServer`.

### Request

O Request é a requisição feita pelo servidor ao usuário. Nele contém as informações que foram solicitas, os paramêtros e caminhos necessários para aquela requisição.

### Response

O Response é a resposta fornecida do servidor para o usuário. Por exemplo, uma validação, alterações ou até mesmo uma mensagem de erro.

## O que é e para que serve a Querystring?

A QueryString é usada para passa paramêtro para o servidor. Por exemplo, um metodo especifica à ser executado, paramêtro de acessos entre outros. Veja um exemplo:

```
http://localhost:8080/validaNomeEIdade?nome=Gabriel&idade=29
```

## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:

```
'use strict';

var date = (new Date()).toJSON();

const http = require('http')
    , SUCCESS = {
        version: '1.0'
      , name: 'Be MEAN'
      , returned_at: date
    }
    , ERROR = {
        message: "Não encontrado!"
      }
    ;

http.createServer(function(req, res){
    switch(req.url) {
        case '/api/pokemons/create':
        case '/api/pokemons/read':
        case '/api/pokemons/update':
        case '/api/pokemons/delete':
            res.writeHead(200, {'Content-Type': 'application/json'});
            res.write(JSON.stringify(SUCCESS));
            break;
        default:
            res.writeHead(404, {'Content-Type': 'application/json; charset=utf-8'});
            res.write(JSON.stringify(ERROR));
    }
  res.end();
}).listen(3000, function(){
  console.log('Servidor rodando em localhost:3000');
});

```


text:
```md
# Node.js - Aula 02 - Exercício
**user:** [josecarlosweb](https://github.com/josecarlosweb)
**autor:** SEU NOME COMPLETO

## Quais são os 4 verbos que utilizamos para o CRUD?
C - Create - Criar/Inserir/Salvar
R - Retrieve - Recuperar/Pegar
U - Update - Atualizar
D - Delete - Apagar

## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).

Os Status Code são uma maneira de informar o status da comunicação entre cliente e servidor. Utilizando de códigos numéricos, uma aplicação no servidor ou no cliente podem identificar ou informar quando um determinado evento aconteceu (Ex. erro, endereço movido, não autorizado dentre outros).
Exemplo do erro 500 (erro interno do servidor):
![500](https://http.cat/500)

## Explique o que é cada parâmetro da função recebida no `createServer`.
A função createServer recebe uma função de _callback_ que tem dois parâmetros:
1. request: Chamado sempre há uma solicitação. Note-se que pode haver vários pedidos por conexão (no caso de conexões keep-alive). request é uma instância de http.IncomingMessage
2. response é uma instância de http.ServerResponse. Chamado quando é recebida uma resposta a esse pedido. Este evento é executado apenas uma vez.

## O que é e para que serve a Querystring?

É uma forma de passar variáveis e valores via URL, ou seja, via requisição GET.

## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:

```js
//server js

'use strict';

var date = (new Date()).toJSON();

const http = require('http'),
metadados = {
    version: 1.0,
    returned_at: date,
}
, CREATE = {
    name: 'CREATE A POKEMON',
    meta: metadados,
}
, READ = {
    name: 'READ A POKEMON',
    meta: metadados,
}
, UPDATE = {
    name: 'UPDATE A POKEMON',
    meta: metadados,
}
, DELETE = {
    name: 'DELETE A POKEMON',
    meta: metadados,
}
, ERROR = {
    message: "Erro! Digite uma url válida"
};

http.createServer(function(req, res){
    res.writeHead(200, {'Content-Type':'application/json; charset=utf-8'});
    var write = ERROR;

    switch(req.url){
        case '/api/pokemons/create': write = CREATE; break;
        case '/api/pokemons/read': write = READ; break;
        case '/api/pokemons/update': write = UPDATE; break;
        case '/api/pokemons/delete': write = DELETE; break

        default: res.writeHead(404, {'Content-Type':'application/json; charset=utf-8'}); break;
    }

    res.write(JSON.stringify(write));
    res.end();

}).listen(3000, function(){
    console.log("Server Js na porta 3000");
})

```


text:
# Node.js - Aula 02 - Exercício
**user:** [ajoao88](https://github.com/ajoao88)
**autor:** João Paulo S de Araújo
**date:** 1454895260625

## Quais são os 4 verbos que utilizamos para o CRUD?

CRUD | Descrição | Verbo |
-----|-----------|-------|
C|Create|POST
R|Retrieve|GET
U|Update|PUT
D|Delete|DELETE

## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).

Para padronizar a comunicação entre cliente e servidor, com os **status codes** fica clara a resposta do servidor para a requisição feita, permitindo tratá-la adequadamente.

##### 101 - Mudando protocolos
![Mudando protocolos](https://http.cat/101)
Isso significa que o solicitante pediu ao servidor para mudar os protocolos e o servidor está reconhecendo que irá fazê-lo

##### 204 - Nenhum Conteúdo
![Nenhum conteúdo](https://http.cat/204)
O servidor processou a solicitação com sucesso, mas não é necessário nenhuma resposta.

##### 301 - Movido permanentemente
![Movido permanentemente](https://http.cat/301)
Esta e todas as solicitações futuras devem ser direcionada para o URI .

##### 402 - Pagamento Necessário
![Pagamento Necessário](https://http.cat/402)
Reservado para uso futuro. A intenção original era que esse código pudesse ser usado como parte de alguma forma de dinheiro digital ou de micro pagamento regime, mas isso não aconteceu, e esse código não é usado normalmente.

##### 500 - Erro interno no servidor
![Erro interno no servidor](https://http.cat/500)
O servidor ainda não suporta a funcionalidade ativada

## Explique o que é cada parâmetro da função recebida no `createServer`.

Existem dois parâmetros ao criar um servidor com a função `createServer`, `request` e `response`.

`Resquest` é um objeto do tipo **http.IncommingMessage**,
Armazena os dados da requisição do cliente.
`Response` é um objeto do tipo **http.ServerResponse**
É o callback que será retornado para o cliente que fez a requisição.

## O que é e para que serve a Querystring?

`Querystring` é um modelo de passagem de informações entre cliente e servidor, nele são enviados conjuntos de propriedade e valor, onde a propriedade e valor são separados por "=" e os conjuntos são separados por "&".
São enviado via **url** no final do endereço após um "?".

Ex.: http://enderecoweb/?nome=joao&idade=28

No final do endereço é introduzido um ponto de interrogação e logo em seguida os pares de propriedade e seu valor.

## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
- /api/pokemons/create
- /api/pokemons/read
- /api/pokemons/update
- /api/pokemons/delete

```js
'use strict';

const http = require('http')
, url = require('url')
, SUCCESS = {
    version: '1.5'
    , name: ''
    , returned_at: new Date().toJSON()
}
, ERROR = {
    message: "Sinto muito, endereço não encontrado"
}
;

var rotas = {
    create: function(){SUCCESS.name = 'João Paulo - Exercício 02 - Rota: /api/pokemons/create'}
    , read: function(){SUCCESS.name = 'João Paulo - Exercício 02 - Rota: /api/pokemons/read'}
    , update: function(){SUCCESS.name = 'João Paulo - Exercício 02 - Rota: /api/pokemons/update'}
    , delete: function(){SUCCESS.name = 'João Paulo - Exercício 02 - Rota: /api/pokemons/delete'}
};

http.createServer(function(req, res){
    rotas.parametros = url.parse(req.url, true);
    try{
        var rota = req.url.replace(/\/api\/pokemons\//i, '');
        rotas[rota]();
        res.writeHead(200, {'Content-Type': 'application/json;charset=utf-8'});
        res.write(JSON.stringify(SUCCESS));
    }catch(e){
        res.writeHead(404, {'Content-Type': 'application/json; charset=utf-8'});
        res.write(JSON.stringify(ERROR));
    }
    res.end();
}).listen(3000, function(){
    console.log('Servidor escutando em localhost:3000');
});
```


text:
# Node.js - Aula 02 - Exercício
**user:** [Cerezini](https://github.com/Cerezini)
**autor:** Mateus Cerezini Gomes

## Quais são os 4 verbos que utilizamos para o CRUD?

- POST = Create
- GET = Read/Retrieve
- PUT = Update
- DELETE

## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).

Os status codes informam sobre o processamento (sucesso, erros, informações) da requisição através do *header* da resposta.

### 1XX - Informação

![alt text](https://http.cat/100 "100")

### 2XX - Sucesso

![alt text](https://http.cat/202 "202")

### 3XX - Redirecionamento

![alt text](https://http.cat/304 "304")

### 4XX - Erro no Cliente

![alt text](https://http.cat/413 "413")

### 5XX - Erro no Servidor

![alt text](https://http.cat/599 "599")

## Explique o que é cada parâmetro da função recebida no `createServer`.

- **Request** é o objeto que contém os dados do pedido feito ao servidor.
- **Response** é o objeto resposta com as informações requeridas no pedido que será retornado ao cliente.

## O que é e para que serve a Querystring?

A *querystring* é uma string com os parâmetros de busca passados em uma chamada HTTP GET, ou seja, são informações necessárias para retornar o(s) objeto(s) desejado(s) na chamada GET.
Ex: Gostaria de receber todos os carros feitos em 2008 da cor azul, logo a *querystring* teria algo como `carro?ano=2008&cor=azul`.

## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
- /api/pokemons/create
- /api/pokemons/read
- /api/pokemons/update
- /api/pokemons/delete

```js
// server.js
'use strict';

var date = (new Date()).toJSON();

const http = require('http')
    , url = require('url')
    , SUCCESS = {
        version: '1.0'
        , name: 'Be MEAN'
        , returned_at: date
        }
    , ERROR = {
        message: 'Não encontrado'
    };

http.createServer(function(req, res){
    var route = url.parse(req.url, true).pathname;

    switch (route) {
        case '/api/pokemons/create':
            res.writeHead(200, {'Content-Type': 'application/json'});
            res.write(JSON.stringify(SUCCESS));
            break;

        case '/api/pokemons/read':
            res.writeHead(200, {'Content-Type': 'application/json'});
            res.write(JSON.stringify(SUCCESS));
            break;

        case '/api/pokemons/update':
            res.writeHead(200, {'Content-Type': 'application/json'});
            res.write(JSON.stringify(SUCCESS));
            break;

        case '/api/pokemons/delete':
            res.writeHead(200, {'Content-Type': 'application/json'});
            res.write(JSON.stringify(SUCCESS));
            break;

        default:
            res.writeHead(404, {'Content-Type': 'application/json; charset=utf-8'});
            res.write(JSON.stringify(ERROR));
            break;
    }

    res.end();
}).listen(3000, function(){
    console.log('Servidor rodando em localhost:3000');
});
```


text:
# Node.js - Aula 02 - Exercício

**user:** https://github.com/paulosilva92

**autor:** Paulo Roberto da Silva

**date:** Sat Feb 27 2016 15:29:13 GMT-0300 (BRT)

## Quais são os 4 verbos que utilizamos para o CRUD?

São os métodos :

Post: que seria a parte de Create(C).

Get: que corresponde ao Read(R).

Put: que seria o Update(U)

Delete: que seria o Delete(D)

## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do Cat Status Code.

Para facilitar a comunicação entre servidor e cliente através de códigos com diferente significados pré-determinados.

##### 101 - Switching Protocols

![Image](https://http.cat/101);

##### 202 - Accepted

![Image](https://http.cat/202);

##### 303 - See Other

![Image](https://http.cat/303);

##### 409 - Conflict

![Image](https://http.cat/409);

##### 506 - Variant Also Negotiates

![Image](https://http.cat/506);

## Explique o que é cada parâmetro da funçãorecebida no `createServer`

##### request

É o parametro que irá receber toda as informações a respeito da requisição feita no servidor, como cabeçalhos, url, body.

##### reponse

É o objeto que armazenará todas as informações que o servidor enviará na sua resposta da requisição. Esse é o objeto que modificaremos com as informações que queremos que o servidor envie para o cliente que fez determinada requisição.

## O que é e para que serve a Querystring?

A QueryString é um modelo clássico de manutenção do estado da página. Elas são nada mais do que conjuntos de pares/valores anexados a URL. Seu uso é simples, após a URL de determinada página, adicionamos o primeiro valor usando a seguinte sintaxe: ?Chave=Valor. Para passarmos mais de um conjunto, os mesmos devem ser concatenados usando o caractere coringa `&`.

## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:

```js
'use strict';
var date =  (new Date()).toJSON();
const http = require('http')
      ,url = require('url')
      ,SUCCESS = {
        version: 1.0
        ,name: 'Be Mean'
        ,created_at: date
      }
      ,ERROR = {
        message : 'deu merda'
      };

var rotas = {
    create: function(){
      SUCCESS.name = 'Pokemon Criado'
    },
    read: function(){
      SUCCESS.name = 'Pokemon Lido'
    },
    update: function(){
      SUCCESS.name = 'Pokemon Atualizado'
    },
    delete: function(){
      SUCCESS.name = 'Pokemon Deletado'
    }
  }

http.createServer(function(req, res){
  rotas.parametros = url.parse(req.url, true);
  try{

    // remove a descrição /api/pokemons
    var rota = req.url.replace(/\/api\/pokemons\//gi, '');

    rotas[rota]();

    res.writeHead(200, {'Content-Type': 'application/json'});
    res.write(JSON.stringify(SUCCESS));

  }catch(e){
    res.writeHead(404, {'Content-Type': 'application/json; charset=utf-8'});
    res.write(JSON.stringify(ERROR));
  }
  res.end();
}).listen(3000, function(){
  console.log('Servidor rodando em localhost:3000');
});
```


text:
# Node.js - Aula 02 - Exercício
**Autor:** Diego Ferreira
**Data:** 1456489472714

## Quais são os 4 verbos que utilizamos para o CRUD?

Uma operação de CRUD, realiza as operações de CREATE, READ, UPDATE, DELETE, em uma requisição estes métodos são representados pelos seguintes verbos:

CREATE -> POST (envia uma requisição para o servidor passando parâmetro),

READ -> GET ( solicita alguma informação de um recurso do servidor),

UPDATE -> PUT ( envia uma requisição passando parâmetros, para atualização de um recurso já existente.),

DELETE -> DELETE ( Remove o recurso especificado )

## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).

Os status cod foram criados para padronizar a conversa entre cliente e servidor, padronizando códigos e status com o intuito de identificar de maneira mais clara o resultado do processamento de uma requisição.
Os status foram divididos em 5 grupos, 1XX, 2XX, 3XX, 4XX, 5XX, conforme abaixo:

* 1XX - Informativos

Ex.:
100 - Continue

Esta é uma resposta provisória usada para informar ao cliente que a parte inicial da solicitação foi recebida e não foi rejeitada pelo servidor. Diante deste status o cliente deve continuar enviando o restante do pedido ou, se o pedido já foi concluído, ignorar esta resposta.

![image](https://http.cat/100)

* 2XX - SUCESSO

Ex.:
200 - OK

Requisição efetuada com sucesso.

![image](https://http.cat/200)

* 3XX - Redirecionamento

Ex.:
301 - Movido Permanentemente

Indica que o recurso solicitado foi movido permanentemente para outro endereço.

![image](https://http.cat/301)

* 4XX - Erro do Cliente

Ex.:
403 - Forbidden

O servidor entendeu a solicitação mais recusou a responder.

![image](https://http.cat/403)

* 5XX - Erro do Servidor

Ex.:
503 - Service Unavaliable

O servidor não consegue processar a requisição devido a uma sobrecarga ou manutenção no servidor.

![image](https://http.cat/503)

## Explique o que é cada parâmetro da função recebida no `createServer`.

A função create server recebe 2 parâmetros resquest e reponse.
###### Request
Variável que recebe os dados da requisição enviada pelo cliente.

###### Response
Variável para responder para o cliente as informações ou mensagens de erro provenientes da requisição realizada.

## O que é e para que serve a Querystring?

QueryString é um padrão que permite passar parametros e valores na URL em uma requisição, utilizando o método GET.

## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
/api/pokemons/create - /api/pokemons/read - /api/pokemons/update - /api/pokemons/delete

```
'use strict';

const http = require('http'),
  SUCCESS = {
    version:1.0,
    name: 'BE MEAN',
    created_at: Date.now()},
  ERROR = { message: "URL solicitada não encontrada"};

http.createServer (function(req,resp){
  switch ( req.url ) {
      case '/api/pokemons/create':
    sucesso(resp);
          break;
      case '/api/pokemons/read':
          sucesso(resp);
          break;
      case '/api/pokemons/update':
          sucesso(resp);
          break;
    case '/api/pokemons/delete':
        sucesso(resp);
      break;
      default:
    error(resp);
  }
  resp.end();
}).listen(3000,function(){
  console.log("Servidor rodando na porta 3000!!!");
});

function cabecalho(requestCode, resp){
  resp.writeHead(requestCode, {'Content-Type':'application/json;charset=utf-8'});
}

function sucesso(resp){
  cabecalho(200, resp);
  resp.write(JSON.stringify(SUCCESS));
}

function error(resp){
  cabecalho(404, resp);
  resp.write(JSON.stringify(ERROR));
}

```

## Bibliografia
https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html


text:
# Node.js - Aula 02 - Exercício
**user:** [gustavoprado013](https://github.com/gustavoprado013)
**autor:** Gustavo Prado

## Quais são os 4 verbos que utilizamos para o CRUD?

- Create - Criar
- Retrieve/Read - Recuperar/Ler
- Update - Atualizar
- Delete - Excluir

## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat).

Os Status Codes foram criado para padronizar o retorno da requisições via HTTP para:
	* Informação.
		- 100 (continue): O cliente deve continuar com o pedido, é uma resposta provisória para informar o cliente que a solicitação foi recebida e não foi rejeitada pelo servidor. Cat Status Code (https://http.cat/100).

	* Sucesso.
		- 202 (accepted): O pedido foi aceito para processamento, porém o processamento ainda não foi concluído. É uma resposta intencionalmente nao comprometedora para que o servidor possa aceitar um pedido de algum outro processo. Cat Status Code  (https://http.cat/202).

	* Redirecionamento.
		- 302 (found): É utilizado para informar que o recurso solicitado está temporáriamente em uma URI diferente. O cliente deve continuar usando a URI solicitada para futuras solicitações. Cat Status Code (https://http.cat/302).

	* Erro do cliente.
		- 403 (Forbidden): O servidor entendeu a solicitação mais não a executará. Ou seja o servidor proibido essa solicitação e deve ser enviado o motivo de ter proibido na entity. Se desejar ser público o 404 pode ser usado no lugar. Cat Status Code (https://http.cat/403).

	* Erro do servidor.
		- 502 (Bad Gateway): O servidor é usado como GateWay ou Proxy. recebe uma responsta inválida do servidor superior, ao tentar executar a solicitação. Cat Status Code (https://http.cat/502).

## Explique o que é cada parâmetro da função recebida no `createServer`.

É passada uma função anônima onde a mesma é executada somente naquele momento e retorna para o cliente que realizou a requisição e é passado os seguintes parâmetros para a mesma:

- request: É o parâmetro onde os dados da requisição chegam para nosso servidor.
- response: É o nosso callback e o que será retornado para a requisição solicitada.

## O que é e para que serve a Querystring?

A querystring é um conjunto de caracteres de entrada para um computador ou browser da Web e enviado para um programa de consulta para recuperar informações específicas a partir de um banco de dados.

Na Internet, uma string de consulta (também chamado de querystring HTTP) faz parte do conjunto de caracteres de entrada automaticamente na barra de endereço de um site dinâmico quando um usuário faz uma solicitação de informação de acordo com certos critérios.

Em uma URL (Uniform Resource Locator), a querystring possui um símbolo de separação, geralmente um ponto de interrogação (?). Os dados aparecem logo após este símbolo de separação. Por exemplo, considere o seguinte URL:

	http://www.example.com?name=Gustavo&materia=JS&age=20

A querystring neste exemplo consiste de um campo ou variável, tecnicamente chamada de chave neste contexto (no exemplo é a palavra "name"), seguido por um sinal de igual (=), seguido pelo valor (no exemplo é o nome "angelo"). Cada chave e seu valor correspondente, indicado como uma equação, é chamado de par chave-valor. A querystring pode conter vários pares de chave-valores. Quando há mais de um par chave-valor, eles são tipicamente separados por um e comercial (&).

## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:

```js
'use strict';

var date = (new Date()).toJSON();

var http = require('http')
	  , SUCCESS = {
		  version: '1.0'
	  	, name: 'Be MEAN'
	  	, returned_at: date
	  	}
	  ,	ERROR = {
	  		message: "Not Found!"
	  	};
var url = require('url');

http.createServer(function(req, res) {

	var url_parse = url.parse(req.url);

	switch(url_parse.pathname) {
		case '/api/pokemons/create':
		case '/api/pokemons/read':
		case '/api/pokemons/update':
		case '/api/pokemons/delete':
			res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8'});
			res.write(JSON.stringify(SUCCESS));
			break;
		default:
			res.writeHead(404, { 'Content-Type': 'application/json; charset=utf-8'});
			res.write(JSON.stringify(ERROR));
	}

	res.end();

}).listen(3000, function() {
	console.log('Servidor rodando em localhost:3000');
});
```


text:
# Node.js - Aula 02 - Exercício
**User:** [DouglasHennrich](https://github.com/DouglasHennrich)

**Autor:** Douglas Hennrich

**Date:** 1449889648726

## Quais são os 4 verbos que utilizamos para o CRUD?
* **C** reate   - `POST`
* **R** etrieve - `GET`
* **U** pdate   - `PUT`
* **D** elete   - `DELETE`

## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
Os `Status Codes` foram inventados para padronizar os tipos de retorno do servidor, facilitando o entendimento deles.

* **1XX** - Information

![](https://http.cat/101)

* **2XX** - Successful

![](https://http.cat/206)

* **3XX** - Redirection

![](https://http.cat/307)

* **4XX** - Client Error

![](https://http.cat/409)

* **5XX** - Server Error

![](https://http.cat/509)

## Explique o que é cada parâmetro da função recebida no `createServer`.
* **Request** - Contêm os parâmetros da requisição feita pelo Usuário

* **Response** - Contêm métodos para escrever respostas para o Usuário

## O que é e para que serve a Querystring?
* **O que é** - Conjunto de `key`/`value` anexados a URL

* **Para o que serve** - Passar parâmetros para o servidor através do método `GET`

## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:

```js
'use strict';

var date = (new Date()).toJSON();

const http = require('http')
  , SUCCESS = {
      version: 1.0
    , code: 200
    , name: 'Be MEAN'
    , created_at: date
    }
  , ERROR = {
      message: "Method Not Allowed"
    , code: 405
    }
  ;

http.createServer(function(req, res){
    let url = req.url
      , method = req.method
      ;

    switch(url){
        case "/api/pokemons/create":
            if(method === "POST"){
                res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
                res.write(JSON.stringify(SUCCESS));
            }else{
                res.writeHead(405, { 'Content-Type': 'application/json; charset=utf-8' });
                res.write(JSON.stringify(ERROR));
            }
            break;

        case "/api/pokemons/read":
            if(method === "GET"){
                res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
                res.write(JSON.stringify(SUCCESS));
            }else{
                res.writeHead(405, { 'Content-Type': 'application/json; charset=utf-8' });
                res.write(JSON.stringify(ERROR));
            }
            break;

        case "/api/pokemons/update":
            if(method === "PUT"){
                res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
                res.write(JSON.stringify(SUCCESS));
            }else{
                res.writeHead(405, { 'Content-Type': 'application/json; charset=utf-8' });
                res.write(JSON.stringify(ERROR));
            }
            break;

        case "/api/pokemons/delete":
            if(method === "DELETE"){
                res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
                res.write(JSON.stringify(SUCCESS));
            }else{
                res.writeHead(405, { 'Content-Type': 'application/json; charset=utf-8' });
                res.write(JSON.stringify(ERROR));
            }
            break;

        default:
            res.writeHead(404, { 'Content-Type': 'application/json; charset=utf-8' });
            ERROR.message = "Not Found";
            ERROR.code = 404
            res.write(JSON.stringify(ERROR));
            break;
    }

    res.end();
})
 .listen(3000, function(){
    console.log('Servidor rodando em localhost:3000');
 });
```


text:
# Node.js - Aula 02 - Exercício
**user:** [lesilva00](https://github.com/lesilva00)
**autor:** Luís Eduardo Tenório Silva

## Quais são os 4 verbos que utilizamos para o CRUD?
Create (Criar), Read (Ler), Udpate(Atualizar) e Delete(Deletar).

## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).

Os Status Codes foram criados para informar ao cliente o estado do servidor e de sua solicitação. Esses Status Codes são definidos pelo servidor web no cabeçalho das respostas HTTP que serão passadas aos clientes ou indexadores.

####**1XX:** Informacional
Responsável para informar o usuário algumas ações do servidor
Mudando protocolos: ![101](https://http.cat/101)

####**2XX:** Sucesso
Responsável por informar que a ação solicitada pelo usuário foi recebida, compreendida, aceita e processada com êxito
OK: ![200](https://http.cat/200)

####**3XX:** Redirecionamento
Responsável por informar que a ação necessita de redirecionamento para ser completada. Esse redirecionamento vai desde a mudança de localização temporária da página, mudança permanente, redirecionamento de gateway entre outros.
Movido temporariamente: ![302](https://http.cat/302)

####**4XX:** Erro do Cliente
Responsável de informar a existência de um erro provindo da solicitação do cliente.

Não encontrado: ![404](https://http.cat/404)

####**5XX:** Erro do Servidor
Responsável por informar a existência de um erro provindo do servidor. Geralmente esses erros ocorrem devido a uma má configuração do ambiente ou a problemas internos.

Bad gateway: ![502](https://http.cat/502)

## Explique o que é cada parâmetro da função recebida no `createServer`.

**Request:**
Contém dados da requisição do cliente (Ex: url).

**Response:**
Dados de resposta a solicitação realizada pelo usuário. Aqui é comum definir o Status Code da solicitação e a página que será carregada pelo usuário.

## O que é e para que serve a Querystring?
Conjunto formado por chave/valor que contém informações gerais da solicitação do cliente.

## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
- /api/pokemons/create
- /api/pokemons/read
- /api/pokemons/update
- /api/pokemons/delete

```js
'use strict';

var date = (new Date()).toJSON();
var http = require('http');
var url = require('url');

const SUCCESS = {
    version:'1.0',
    name:'Success',
    returned_at:date
}
, ERROR = {
    message:'Não encontrado'
}

http.createServer(function(req,res){
    var urlInitial = '/api/pokemons/'
    var result = url.parse(req.url,true);
    switch(result.pathname){
        case urlInitial+'create':
            res.writeHead(200,{'Content-Type':'application/json; charset=utf-8'});
            res.write(JSON.stringify(SUCCESS));
            break;
        case urlInitial+'read':
	    res.writeHead(200,{'Content-Type':'application/json; charset=utf-8'});
	    res.write(JSON.stringify(SUCCESS));
	    break;
        case urlInitial+'update':
	    res.writeHead(200,{'Content-Type':'application/json; charset=utf-8'});
	    res.write(JSON.stringify(SUCCESS));
	    break;
	case urlInitial+'delete':
	    res.writeHead(200,{'Content-Type':'application/json; charset=utf-8'});
	    res.write(JSON.stringify(SUCCESS));
	    break;
	default:
	    res.writeHead(404,{'Content-Type':'application/json; charset=utf-8'});
	    res.write(JSON.stringify(ERROR));
    }
    res.end();

}).listen(8080,function(){
    console.log('Servidor rodando na porta 8080, pressione ^C para sair...');
});
```


text:
# Node.js - Aula 02 - Exercício
**user:** [FrancisoValerio]https://github.com/FranciscoValerio
**autor:** Francisco Henrique Ruiz Valério

## Quais são os 4 verbos que utilizamos para o CRUD?

- Create
- Retrieve/Read
- Update
- Delete

## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).

Os Status Codes foram criado para padronizar o retorno da requisições via HTTP para:
	* Informação.
		- 100 (continue): O cliente deve continuar com o pedido, é uma resposta provisória para informar o cliente que a solicitação foi recebida e não foi rejeitada pelo servidor. Cat Status Code (https://http.cat/100).

	* Sucesso.
		- 202 (accepted): O pedido foi aceito para processamento, porém o processamento ainda não foi concluído. É uma resposta intencionalmente nao comprometedora para que o servidor possa aceitar um pedido de algum outro processo. Cat Status Code  (https://http.cat/202).

	* Redirecionamento.
		- 302 (found): É utilizado para informar que o recurso solicitado está temporáriamente em uma URI diferente. O cliente deve continuar usando a URI solicitada para futuras solicitações. Cat Status Code (https://http.cat/302).

	* Erro do cliente.
		- 403 (Forbidden): O servidor entendeu a solicitação mais não a executará. Ou seja o servidor proibido essa solicitação e deve ser enviado o motivo de ter proibido na entity. Se desejar ser público o 404 pode ser usado no lugar. Cat Status Code (https://http.cat/403).

	* Erro do servidor.
		- 502 (Bad Gateway): O servidor é usado como GateWay ou Proxy. recebe uma responsta inválida do servidor superior, ao tentar executar a solicitação. Cat Status Code (https://http.cat/502).

## Explique o que é cada parâmetro da função recebida no `createServer`.

É passada uma função anônima onde a mesma é executada somente naquele momento e retorna para o cliente que realizou a requisição e é passado os seguintes parâmetros para a mesma:

- request: É o parâmetro onde os dados da requisição chegam para nosso servidor.
- response: É o nosso callback e o que será retornado para a requisição solicitada.

## O que é e para que serve a Querystring?

Querystring é padrão adotado pelo protocolo HTTP e serve para transportar informações do cliente para o servidor.

Utiliza-se do seguinte padrão:
	variavel=conteudo

## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:

'use strict';

var date = ( new Date()).toJSON();

const http = require('http')
	, url = require('url')
	, SUCCESS = {
		version: "1.0"
		, name: 'Be MEAN'
		, created_at: date
	}
	, ERROR = {
		message: "Não econtrado!"
	};

http.createServer( function ( request, response ){

	var url_parse = url.parse(request.url);

	switch(url_parse.pathname) {
		case '/delete':
		case '/query':
		case '/edit':
		case '/new':
			response.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8'});
			response.write(JSON.stringify(SUCCESS));
			break;
		default:
			response.writeHead(404, { 'Content-Type': 'application/json; charset=utf-8'});
			response.write(JSON.stringify(ERROR));
	}

	response.end();
}).listen(3000, function(){
	console.log('Servidor rodando em localhost:3000');
});


text:
# Node.js - Aula 02 - Exercício
**user:** [yesroh](https://github.com/yesroh)

**autor:** Ronaiza Cardoso

**Date:** 1469731861509

## Quais são os 4 verbos que utilizamos para o CRUD?

- Create
- Retrieve
- Update
- Delete

## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).

Serve para informar o que o servidor esta respondendo.

## 1XX - Informação
![100](https://http.cat/100)

## 2XX - Sucesso
![200](https://http.cat/200)

## 3XX - Redirecionamento
![303](https://http.cat/303)

## 4XX- Erro de cliente
![403](https://http.cat/403)

## 5XX - Erro de servidor
![500](https://http.cat/500)

## Explique o que é cada parâmetro da função recebida no `createServer`.

- request: informações de requisição feita pelo cliente;
- response: informações de resposta do servidor para o cliente.

## O que é e para que serve a Querystring?

Querystring é uma forma de passar os valores pela url, assim podemos pegar os valores da nossa url com nosso request.

## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:

```js
'use strict';

var date = (new Date()).toJSON();

const http = require('http')
    , SUCCESS = {
        version: '1.0'
      , name: 'Be MEAN'
      , returned_at: date
    }
    , ERROR = {
        message: "Não encontrado!"
      }
    ;

http.createServer(function(req, res){
    switch(req.url) {
        case '/rota/v1':
        case '/rota/v2':
        case '/rota/v3':
        case '/rota/v4':
            res.writeHead(200, {'Content-Type': 'application/json'});
            res.write(JSON.stringify(SUCCESS));
            break;
        default:
            res.writeHead(404, {'Content-Type': 'application/json; charset=utf-8'});
            res.write(JSON.stringify(ERROR));
    }
  res.end();
}).listen(3000, function(){
  console.log('Servidor rodando em localhost:3000');
});

```


text:
# Node.js - Aula 02 - Exercício
**user:** [felipelopesrita](https://github.com/felipelopesrita)
**autor:** Felipe José Lopes Rita

## Quais são os 4 verbos que utilizamos para o CRUD?
Para a criação do CRUD, utilizaremos os verbos POST para o CREATE, GET para Retrive/Read, PUT para UPDATE e DELETE para DELETE (esse ficou meio redundante)

## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
Os códigos de retorno são padronizados e tem como intuito direcionar a identificação do conteúdo de retorno ao cliente. Por exemplo, uma aplicação pode facilmente estar escrita em russo (aplicações de ak-47 e vodkas), mas se ao acessá-la ela retornar o código `404` sei que a uri que requisitei não existe, mesmo não falando russo.
**1XX**
São códigos que indicam apenas informações a respeito da requisição, como por exemplo o código 101: Mudando protocolos. Esse código significa que foi requisitado uma mudança de protocolo e que o servidor reconheceu isso e irá fazê-la.
![101 Status](https://http.cat/101)
**2XX**
Código para informa que a requisição foi recebida, aceita e executada com sucesso, como o status 200, OK, padrão de resposta para requisições HTTP realizadas com êxito.
![200 Status](https://http.cat/200)
**3XX**
Informa ao cabeçalho HTTP que será necessária uma mudança de página(redirecionamento). Um fato interessante é que o servidor só pode fazer esse redirecionamento automaticamente, isto é, sem uma interação com o usuário, quando o verbo da requisição é o GET ou HEAD.
Um exemplo desse status é o 301, que informa que a solicitação corrente, bem como todas as futuras, devem ser direcionadas ao URI.
![301 Status](https://http.cat/301)
**4XX**
Essa classe de status são utilizadas para indicar possíveis erros cometidos pelo cliente, como por exemplo o 404, onde o cliente tenta acessar o serviço através de uma uri inexistente, ou mesmo o erro 400, que indica que a requisição não pode ser realizada devido à sintaxe incorreta no pedido
![400 Status](https://http.cat/400)
**5XX**
Indicam erros internos do servidor, apresentados durante o processamento da requisição, como por exemplo o erro 503, que informa que o serviço requisitado está indisponível devido a uma manutenção ou a uma sobrecarga do sistema.
![503 Status](https://http.cat/503)

## Explique o que é cada parâmetro da função recebida no `createServer`
```js
function (request. response){}
```
**Request**
Armazena os dados referentes a requisição http efetuada, para que seja possível determinar o que deve ser feito.
**Response**
É um objeto de resposta utilizado para retornar os dados requisitados pelo cliente

## O que é e para que serve a Querystring?
São um ou diversos conjuntos de pares de valores(chave=valor) contidos numa requisição http. E são utilizados para transportar valores de forma rápida e fácil, para que eles possam ser usados como parâmetros de uma requisição.

## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
```js
'use strict';

var date = (new Date()).toJSON()
  , rotes =
    { 'create': 'Rota acessada: Create'
    , 'read': 'Rota acessada: Read'
    , 'update': 'Rota acessada: Update'
    , 'delete': 'Rota acessada: Delete'
    }
  ;

const http = require('http')
  , url = require('url')
  , SUCCESS = {
      version: 1.0
    , name: 'Be Mean'
    , created_at: date
	}
  , ERROR = {
      'message': 'Nâo encontrado'
  	}
  ;

http.createServer(function(req, res){
  try {
    res.writeHead(200, {'Content-Type': 'application/json'});
    var x = req.url.replace(/\/api\/pokemons\//gi, '');
    SUCCESS.rote = rotes[x];
    res.write(JSON.stringify(SUCCESS));
  }
  catch(e) {
    res.writeHead(404, {'Content-Type': 'application/json'});
    console.log(e);
    res.write(JSON.stringify(ERROR))
  }

  res.end();
}).listen(3000, function(){
	console.log('Servidor rodando em localhost:3000');
});

```

## Referências
[HTTP Status Codes](http://www.restapitutorial.com/httpstatuscodes.html#)
[HTTP response codes](https://developer.mozilla.org/en-US/docs/Web/HTTP/Response_codes)


text:
# Node.js - Aula 02 - Exercício
**user:** [rxon7](https://github.com/rxon7)

**autor:** Rony Souza

## Quais são os 4 verbos que utilizamos para o CRUD?

- Create
- Retrieve
- Update
- Delete

## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).

Serve para padronizar o retorno do servidor

## 1XX - Informacional
![100](https://http.cat/100)

## 2XX - Sucesso
![200](https://http.cat/200)

## 3XX - Redirecionamento
![301](https://http.cat/301)

## 4XX- Erro de cliente
![415](https://http.cat/415)

## 5XX - Erro de servidor
![500](https://http.cat/500)

## Explique o que é cada parâmetro da função recebida no `createServer`.

`createServer` é uma função anônima, que é executada automaticamente.

**Request:** É a informação chegando no servidor através do navegador.

**Response:** É a informação chegando no navegador através do servidor.

## O que é e para que serve a Querystring?

Querystring é uma forma de passar os valores pela url e Serve para alterarmos o estado de uma página web.

## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:

```js

var http = require('http');
var STATUS = {};

function setStatus(action, message){
   STATUS = {
      action: action,
      message: message,
      date_at: new Date().toJSON()
   };
}

http.createServer((req, res) => {
   res.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});

   switch(req.url){
      case '/api/pokemons/create':
         setStatus('CREATE', 'Criando um Pokémon.');
      break;
      case '/api/pokemons/read':
         setStatus('READ', 'Retornando um Pokémon.');
      break;
      case '/api/pokemons/update':
         setStatus('UPDATE', 'Atualizando um Pokémon.');
      break;
      case '/api/pokemons/delete':
         setStatus('DELETE', 'Excluindo um Pokémon.');
      break;
      default:
         res.writeHead(404, {'Content-Type': 'application/json'});
         setStatus('ERROR', 'Not found');
      break;
   }
   res.write(JSON.stringify(STATUS));
   res.end();
}).listen(3300, () => {
      console.log('O servidor está rodando em localhost:3300.');
});

```


text:
# Node.js - Aula 02 - Exercício
**user:** [davidsonsns](https://github.com/davidsonsns)

**autor:** Davidson da Silva Nascimento

**date:** Date.now()

## Quais são os 4 verbos que utilizamos para o CRUD?
- **C** POST Criar, inserir

- **R** GET Recuperar, obter

- **U** PUT Atualizar

- **D** DELETE Excluir

## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
Informar ao cliente, através de códigos com significados já pré-definidos, sobre o status da requisição ao servidor. A causa de um erro inesperado poderá ser gerado por ambas as partes.

##### `1xx` Informação
![continue](https://http.cat/100)

O servidor recebeu os cabeçalhos da solicitação, e que o cliente deve proceder para enviar o corpo do pedido

##### `2xx` Sucesso
![accept](https://http.cat/202)

O pedido foi aceito para processamento, mas o tratamento não foi concluído

##### `3xx` Redirecionamento
![multiple](https://http.cat/300)

Indica várias opções para o recurso que o cliente pode acompanhar

##### `4xx` Erro de cliente
![bad](https://http.cat/400)

O pedido não pode ser entregue devido à sintaxe incorreta

##### `5xx` Erro de servidor
![loop](https://http.cat/508)

O servidor detectou um loop infinito ao processar o pedido (enviado em vez de 208)

## Explique o que é cada parâmetro da função recebida no `createServer`.
Suponhamos a seguinte assinatura:
```js
http.createServer(function(request, response){}
```
#### `request`
Objeto de solicitação que contém informações sobre a solicitação do cliente, tais como a URL, cabeçalhos HTTP, e muito mais.

Segue exemplo onde retornamos a rota informada:
```js
request.url
```

#### `response`
Objeto de resposta que é utilizada para devolver dados de volta para o cliente.

Abaixo segue exemplo onde enviamos um código de status HTTP e uma coleção de cabeçalhos de resposta de volta ao cliente:
```js
response.writeHead(200,{"Content-Type":"text/html"});
```

## O que é e para que serve a Querystring?
Conjunto de pares/valores anexados a URL via `GET`. Utilizada para facilitar, na maioria das vezes, o envio de dados estruturados de forma simples e pequena entre cliente/servidor.

Exemplo de URL com QueryString:
```js
.../rota?name=Davidson&sobrenome=Nascimento
```

Exemplo de tratamento no Node.js:
```js
...

http.createServer(function(request, response){

  var queryString = url.parse(request.url, true);

  for(var key in queryString.query){
    response.write(key + ": " + result.query[key]);
  }
}

...
//imprimirá: Davidson Nascimento
```

## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
- /api/pokemons/create
- /api/pokemons/read
- /api/pokemons/update
- /api/pokemons/delete

```js
var date = (new Date()).toJSON();

const http = require('http')
    , url = require('url')
    , SUCCESS = {
        version: '1.0'
      , name: ''
      , returned_at: date
      }
    , ERROR = {
        message: "Não encontrado!"
      }
    ;

var rotas = {
  create: function(){
    SUCCESS.name = 'Be MEAN ENTROU NA ROTA /api/pokemons/create'
  },
  read: function(){
    SUCCESS.name = 'Be MEAN ENTROU NA ROTA /api/pokemons/read'
  },
  update: function(){
    SUCCESS.name = 'Be MEAN ENTROU NA ROTA /api/pokemons/update'
  },
  delete: function(){
    SUCCESS.name = 'Be MEAN ENTROU NA ROTA /api/pokemons/delete'
  }
}

http.createServer(function(req, res){
  rotas.parametros = url.parse(req.url, true);
  try{

    // remove a descrição /api/pokemons
    var rota = req.url.replace(/\/api\/pokemons\//gi, '');

    rotas[rota]();

    res.writeHead(200, {'Content-Type': 'application/json'});
    res.write(JSON.stringify(SUCCESS));

  }catch(e){
    res.writeHead(404, {'Content-Type': 'application/json; charset=utf-8'});
    res.write(JSON.stringify(ERROR));
  }
  res.end();
}).listen(3000, function(){
  console.log('Servidor rodando em localhost:3000');
});
```


text:
# Node.js - Aula 02 - Exercício
# autor: Angelo Rogério Rubin
# data: 1449870839155

## Quais são os 4 verbos que utilizamos para o CRUD?

- Create - Criar
- Retrieve/Read - Recuperar/Ler
- Update - Atualizar
- Delete - Excluir

## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat).

Os Status Codes foram criado para padronizar o retorno da requisições via HTTP para:
	* Informação.
		- 100 (continue): O cliente deve continuar com o pedido, é uma resposta provisória para informar o cliente que a solicitação foi recebida e não foi rejeitada pelo servidor. Cat Status Code (https://http.cat/100).

	* Sucesso.
		- 202 (accepted): O pedido foi aceito para processamento, porém o processamento ainda não foi concluído. É uma resposta intencionalmente nao comprometedora para que o servidor possa aceitar um pedido de algum outro processo. Cat Status Code  (https://http.cat/202).

	* Redirecionamento.
		- 302 (found): É utilizado para informar que o recurso solicitado está temporáriamente em uma URI diferente. O cliente deve continuar usando a URI solicitada para futuras solicitações. Cat Status Code (https://http.cat/302).

	* Erro do cliente.
		- 403 (Forbidden): O servidor entendeu a solicitação mais não a executará. Ou seja o servidor proibido essa solicitação e deve ser enviado o motivo de ter proibido na entity. Se desejar ser público o 404 pode ser usado no lugar. Cat Status Code (https://http.cat/403).

	* Erro do servidor.
		- 502 (Bad Gateway): O servidor é usado como GateWay ou Proxy. recebe uma responsta inválida do servidor superior, ao tentar executar a solicitação. Cat Status Code (https://http.cat/502).

## Explique o que é cada parâmetro da função recebida no `createServer`.

É passada uma função anônima onde a mesma é executada somente naquele momento e retorna para o cliente que realizou a requisição e é passado os seguintes parâmetros para a mesma:

- request: É o parâmetro onde os dados da requisição chegam para nosso servidor.
- response: É o nosso callback e o que será retornado para a requisição solicitada.

## O que é e para que serve a Querystring?

A querystring é um conjunto de caracteres de entrada para um computador ou browser da Web e enviado para um programa de consulta para recuperar informações específicas a partir de um banco de dados.

Na Internet, uma string de consulta (também chamado de querystring HTTP) faz parte do conjunto de caracteres de entrada automaticamente na barra de endereço de um site dinâmico quando um usuário faz uma solicitação de informação de acordo com certos critérios.

Em uma URL (Uniform Resource Locator), a querystring possui um símbolo de separação, geralmente um ponto de interrogação (?). Os dados aparecem logo após este símbolo de separação. Por exemplo, considere o seguinte URL:

	http://www.example.com?name=angelo

A querystring neste exemplo consiste de um campo ou variável, tecnicamente chamada de chave neste contexto (no exemplo é a palavra "name"), seguido por um sinal de igual (=), seguido pelo valor (no exemplo é o nome "angelo"). Cada chave e seu valor correspondente, indicado como uma equação, é chamado de par chave-valor. A querystring pode conter vários pares de chave-valores. Quando há mais de um par chave-valor, eles são tipicamente separados por um e comercial (&).

## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:

'use strict';

var date = (new Date()).toJSON();

var http = require('http')
	  , SUCCESS = {
		  version: '1.0'
	  	, name: 'Be MEAN'
	  	, returned_at: date
	  	}
	  ,	ERROR = {
	  		message: "Not Found!"
	  	};
var url = require('url');

http.createServer(function(req, res) {

	var url_parse = url.parse(req.url);

	switch(url_parse.pathname) {
		case '/api/pokemons/create':
		case '/api/pokemons/read':
		case '/api/pokemons/update':
		case '/api/pokemons/delete':
			res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8'});
			res.write(JSON.stringify(SUCCESS));
			break;
		default:
			res.writeHead(404, { 'Content-Type': 'application/json; charset=utf-8'});
			res.write(JSON.stringify(ERROR));
	}

	res.end();

}).listen(3000, function() {
	console.log('Servidor rodando em localhost:3000');
});


text:
# Node.js - Aula 02 - Exercício
**user:** [vitorcapretz](https://github.com/vitorcapretz)

**autor:** Vitor Capretz

**date:** 1465758182466

## 1. Quais são os 4 verbos que utilizamos para o CRUD?

O CRUD consiste nas 4 principais operações de um sistema, são elas:
* Create - Inserção de novos dados. Ex.: `POST`
* Read - Leitura de dados já inseridos. Ex.: `GET`
* Update - Alteração de dados inseridos. Ex.: `PUT`
* Delete - Exclusão de dados. Ex.: `DELETE`

## 2. Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do `Cat Status Code`.

Cada Status Code representa um tipo de possível retorno de uma requisição, ao fazer uma requisição podemos facilmente comprender se tudo funcionou como esperávamos ou qual foi o comportamento dela.

#### 101 - Continue
![cat_100](https://http.cat/100)

#### 202 - Accepted
![cat_202](https://http.cat/202)

#### 301 - Moved Permanently
![cat_301](https://http.cat/301)

#### 416 - Requested Range Not Satisfiable
![cat_416](https://http.cat/416)

#### 500 - Internal Server Error
![cat_500](https://http.cat/500)

## 3. Explique o que é cada parâmetro da função recebida no `createServer`.

Os parâmetros são:

* Request - Parâmetro do tipo Objeto, onde são enviadas as informações necessárias para o servidor, incluindo cabeçalho, URL, tipo de requisição, etc.
* Response - Parâmetro do tipo Objeto, contém as informações retornadas do servidor para a nossa requisição.

## 4. O que é e para que serve a `Querystring`?

A Querystring fica normalmente no fim da URL e contém variáveis separadas por `&`. Ela pode ser usada para enviar informações para um `GET` de informações em uma API.
Exemplo: `meusite.com.br/api/users/?name=Vitor`

## 5. Escreva no código do server.js uma forma de entregar um JSON de sucesso em 4 rotas diferentes:

```js

'use strict';

let date = (new Date()).toJSON();

const http = require('http');
const successJson = {
    version: 1.0,
    name: 'Be MEAN',
    returned_at: date
};
const errorJson = {
    message: 'Não encontrado!'
};

http.createServer(function(req, res){
    let req_url = req.url;
    switch(req_url){
        case "/api/pokemons/create":
        case "/api/pokemons/read":
        case "/api/pokemons/update":
        case "/api/pokemons/delete":
            res.writeHead(200, {'Content-type': 'application/json; charset=utf-8'});
            res.write(JSON.stringify(successJson));
            break;
        default:
            res.writeHead(400, {'Content-type': 'application/json; charset=utf-8'});
            res.write(JSON.stringify(errorJson));
            break;
    }

    res.end();
}).listen(3000, function(){
    console.log('Server running on localhost:3000');
});

```


text:
# Node.js - Aula 02 - Exercício
**user:** [souzacristsf](https://github.com/souzacristsf)

**autor:** Michel Ferreira Souza

**date:** 1457296166387

## Quais são os 4 verbos que utilizamos para o CRUD?
+ create
+ read
+ update
+ delete

## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
O `Status Code` foi criado para identificar o erro retornado de uma requisição, padronizando o tipo de retorno.

####100
O cliente deve continuar com seu pedido. Esta resposta provisória é usada para informar o cliente que a parte inicial da solicitação foi recebida e ainda não foi rejeitado pelo servidor.

![continue](https://http.cat/100)

####200
O pedido foi bem sucedido.

![ok](https://http.cat/200)

####301
O recurso solicitado foi atribuído um novo endereço permanente e quaisquer futuras referências a este recurso deverá usar um dos endereços devolvidos.

![moved permanently](https://http.cat/301)

####402
Este código é reservado para o uso futuro.

![payment required](https://http.cat/402)

####503
O servidor é atualmente incapaz de lidar com o pedido devido a uma sobrecarga temporária ou manutenção do servidor.

![Service Unavailable](https://http.cat/503)

## Explique o que é cada parâmetro da função recebida no `createServer`.
```js
function (request. response){}
```
*request* requisição feita do lado clienta para o servidor.
*response* analisada a requisição é retornado uma resposta do servidor.

## O que é e para que serve a Querystring?
*Querystring* é um conjunto de valores anexados a **URL** para um propósito no lado servidor.

## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
```js
'use strict';

const PORT=9000;

const http = require('http')
    , date = (new Date()).toJSON()
    , SUCCESS = {
        version: 1
      , name: 'Be Mean'
      , date: date
      }
    , ERROR = {
        message: "Não encontrado!"
      }
    ;
var server = http.createServer(function(request, response){
    switch (request.url) {
        case "/api/pokemons/create":
        case "/api/pokemons/read":
        case "/api/pokemons/update":
        case "/api/pokemons/delete":
            response.writeHead(200, {'Content-type': 'application/json; charset=utf-8'});
            response.write(JSON.stringify(SUCCESS));
            break;
        default:
            response.writeHead(400, {'Content-type': 'application/json; charset=utf-8'});
            response.write(JSON.stringify(ERROR));
            break;
    }
    response.end();
});

server.listen(PORT, function(){
    console.log(server);
    console.log('Servidor rodando em localhost: ' + PORT);
});

```


text:
# Nodejs - Aula 02 - Exercício
autor: Ricardo Pereira

##1. Quais são os 4 verbos que utilizamos para o CRUD?
C = Create(POST)
R = Read(GET)
U = Update(PUT)
D = Delete(DELETE)

##2. Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do Cat Status Code.
Foi criado para dar padrões de resposta e para ter uma orientação melhor dos acontecimentos do servidor, uma leitura mais legível para o homem.

1xx Informational

![alt text](https://http.cat/100)

2xx Success

![alt text](https://http.cat/200)

3xx Redirection

![alt text](https://http.cat/300)

4xx Cliente Error

![alt text](https://http.cat/400)

5xx Server Error

![alt text](https://http.cat/500)

##3. Explique o que é cada parâmetro da função recebida no 'createServer'.
request: reponsável de receber as requisições, url e seus parâmetro por exemplo.
response: responsável de escrever e gerar status do servidor para o cliente.

##4. O que é e para que serve a Querystring?
QueryString em World Wide Web (WWW) é um padrão utilizado para transportar valores em uma uniform resource locator (URL).
Elas são um conjuntos de pares/valores anexados a URL.

##5. Escreva no código do 'server.js' uma forma de entregar um JSON de sucesso em 4 rotas diferentes.
```
'use strict';
const http = require('http')
    , SUCCESS = {
        name: '<h1>Be MEAN</h1>',
    }
    , ERROR = {
        message: "<h1>Not found</h1>"
    };

http.createServer((req, res) => {

    let urls = [ '/api/pokemons/create',
                '/api/pokemons/read',
                '/api/pokemons/update',
                '/api/pokemons/delete'];

    switch (req.url) {
        case urls[0]:
        case urls[1]:
        case urls[2]:
        case urls[3]:
            res.writeHead(200, {'Content-Type': 'text/html; charset=UTF-8'});
            res.write(SUCCESS.name);
            break;
        default:
            res.writeHead(404, {'Content-Type': 'text/html; charset=UTF-8'});
            res.write(ERROR.message);
    }

    res.end();
}).listen(3000, () => {
    console.log('Server start in port 3000');
});
```


text:
# Node.js - Aula 02 - Exercício
**User:** [xereda](https://github.com/xereda)

**Autor:** Jackson Ricardo Schroeder

**Date:** 1464932419174

#### 1 - Quais são os 4 verbos que utilizamos para o CRUD?
* **[ C ]** - `POST`    // create
* **[ R ]** - `GET`     // read/retrieve
* **[ U ]** - `PUT`     // update
* **[ D ]** - `DELETE`  // delete

#### 2 -  Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).

Os _Status Codes_ foram introduzidos para que a comunicação entre um cliente e o servidor de internet fosse padronizada. É baseado numa lista de códigos com 3 algarismos cada, normalizando, dessa forma, os possíveis tipos de retorno de um servidor HTTP.

#### 1XX Informacional
###### 100 - Continue

![](https://http.cat/100)

#### 2XX Sucesso

###### 206 - Partial Content

![](https://http.cat/206)

#### 3XX Redirecionamento

###### 304 - Not Modified

![](https://http.cat/304)

#### 4XX Erro do Cliente

###### 409 - Conflict

![](https://http.cat/409)

#### 5XX Erro de Servidor

###### 502 - Bad Gateway

![](https://http.cat/502)

#### 3 - Explique o que é cada parâmetro da função recebida no `createServer`.

* **Request:** - Parâmetro que contém as informações da requisição feita ao script em questão.

* **Response:** - Parâmetro que estabelece um canal de comunicação com o client da requisição. É um handle para fazer as saídas, ou mais precisamente, o retorno, para o "requisitante".

#### 4 - O que é e para que serve a Querystring?

É uma parte da URL que contém informações da requisição no formato chave/valor. Utilizamos ela com o metodo `GET`.

#### 5 - Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:

* /api/pokemons/create
* /api/pokemons/read
* /api/pokemons/update
* /api/pokemons/delete

```js

// server.js
"use strict";

var date = (new Date()).toJSON();

const http = require("http");
const SUCCESS = { version: 1.0, name: "Be MEAN", returned_at: date };
const ERROR = { message: "Método inválido para esta rota!" };
const ROTA = { message: "Rota inexistente!" };
const ContentType = { "Content-Type": "application/json; charset=utf-8" };

var server = http.createServer(function(req, res) {

  let url = req.url;
  let method = req.method;

  switch (url) {

    case "/api/pokemons/create":

      if (method === "POST") {
        res.writeHead(200, ContentType);
        res.write(JSON.stringify(SUCCESS));
      }
      else {
        res.writeHead(405, ContentType);
        res.write(JSON.stringify(ERROR));
      }
      break;

    case "/api/pokemons/read":

      if (method === "GET") {
        res.writeHead(200, ContentType);
        res.write(JSON.stringify(SUCCESS));
      }
      else {
        res.writeHead(405, ContentType);
        res.write(JSON.stringify(ERROR));
      }
      break;

    case "/api/pokemons/update":

      if (method === "PUT") {
        res.writeHead(200, ContentType);
        res.write(JSON.stringify(SUCCESS));
      }
      else {
        res.writeHead(405, ContentType);
        res.write(JSON.stringify(ERROR));
      }
      break;

    case "/api/pokemons/delete":

      if (method === "DELETE") {
        res.writeHead(200, ContentType);
        res.write(JSON.stringify(SUCCESS));
      }
      else {
        res.writeHead(405, ContentType);
        res.write(JSON.stringify(ERROR));
      }
      break;

    default:
      res.writeHead(404, ContentType);
      res.write(JSON.stringify(ROTA));

  }

  res.end();

});

server.listen(3000, function() {

  console.log("Servidor rodando em localhost:3000");

});

```


text:
# Node.js - Aula 02 - Exercício
**user:** [filipe1309](https://github.com/filipe1309)
**autor:** Filipe Leuch Bonfim

## Quais são os 4 verbos que utilizamos para o CRUD?
  - [**C**] = POST
  - [**R**] = GET
  - [**U**] = PUT
  - [**D**] = DELETE

## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
Os `Status Codes` foram inventados com o intuito de padronizar os retornos das requisições entre o cliente e o servidor, assim podendo ser útil para ajudar a identificar a causa de problemas quando uma página web ou outro recurso não carrega como deveria.

#### 1XX - Informacional
![101](https://http.cat/101)

#### 2XX - Sucesso
![204](https://http.cat/204)

#### 3XX - Redirecionamento
![302](https://http.cat/302)

#### 4XX - Erro do cliente
![403](https://http.cat/403)

#### 5XX - Erro do servidor
![599](https://http.cat/599)

## Explique o que é cada parâmetro da função recebida no `createServer`.
#### Request
O `request` é um objeto que contêm informações sobre o `request` emitido pelo cliente, como por exemplo o cabeçalho HTTP, a URL, etc.

#### Response
O `responce` é um objeto, com diversos métodos, utilizado para retornar dados para o cliente.

## O que é e para que serve a Querystring?
#### O que é?
  `Querystring` é a parte da URL que contem dados. Estes dados são passados como parâmetros no formato de `chave=valor`.

#### Para quer serve?
Serve para passar dados através da URL, utilizando o método `GET`.

## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
```js
'use strict';

var date = (new Date()).toJSON();

const http = require('http')
    , SUCCESS = {
        version: '1.0'
      , name: 'Be MEAN'
      , returned_at: date
      }
    , ERROR = {
        message: "Não encontrado!"
      }
    ;

http.createServer(function(req, res){
  var url_route = '/api/pokemons/';
  var responseStatusCode = 404;
  var responseObj = ERROR;

  switch (req.url) {
    case url_route+'create':
    case url_route+'read':
    case url_route+'update':
    case url_route+'delete':
      responseStatusCode = 200;
      responseObj = SUCCESS;
      break;
  }

  res.writeHead(responseStatusCode, {'Content-Type': 'application/json; charset=utf-8'});
  res.write(JSON.stringify(responseObj));
  res.end();
}).listen(3000, function(){
  console.log('Servidor rodando em localhost:3000');
});
```


text:
# Node.js - Aula 02 - Exercício
**user:** [pedrohills](http://github.com/pedrohills)
**autor:** Pedro Henrique

## Quais são os 4 verbos que utilizamos para o CRUD?
GET, POST, PUT e DELETE.

## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
São compostos, por padrão, por 3 digitos. Os Status Codes são divididos em 5 grupos, os de 100, 200, 300, 400 e 500.

1XX = Informacional: Serve apenas para informar que a informação foi recebida e que o processo continua.
  Exemplo de código: 100 - Continuar: Apenas sinaliza para o usuário continuar com a requisição.
  ![](https://http.cat/100)

2XX = Bem Sucedido:
  Exemplo de código: 200 - OK: Significa que a página web existe e que as operações foram realizadas com sucesso.
  ![](https://http.cat/200)

3XX = Redirecionamento: Notifica ao cabeçalho que houve uma mudança de página...
  Exemplo de código: 302 - Movido Temporariamente: Serve para mover, mas temporariamente.
  ![](https://http.cat/302)

4XX = Erro do Cliente: Erros 4XX devem ser tratados com cuidado. Pois quando há este tipo de erro no cabeçalho o conteúdo não estará acessivel ao usuário nem para os sistemas de busca para indexação.
  Exemplo de código: 401 - Não autorizado: Quando o usuário não tem acesso à página especifica (usuário não autenticado)
  Exemplo de código: 404 - Não encontrado: Famoso código que é retornado quando uma página ou arquivo especifico não existe no servidor..

  ![](https://http.cat/401)
  ![](https://http.cat/404)

5XX = Erro do Servidor: Acontece quando o servidor não consegue processar a requisição por algum motivo... Este erro também não permite a indexação da página.
  Exemplo de código: 503 - Serviço indisponível: É possível ser um erro temporário. Uma manutenção ou uma grande quantidade de requisições realizadas ao servidor que ocasionou em sua queda...
  ![](https://http.cat/503)

## Explique o que é cada parâmetro da função recebida no `createServer`.
No createServer passamos uma função anônima com dois parâmetros, são eles:

request: O request representa a requisição que é requisitada.

response: O response representa a resposta que é recebida.

## O que é e para que serve a Querystring?
São os valores passados pela URL. Serve para passarmos valores para nosso GET.
Exemplo http://localhost:3000?variavel=valor

## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
```javascript
// server.js
'use strict';

var date = (new Date()).toJSON();

const http = require('http');

http.createServer(function(req, res){
	if(req.url === '/api/v1'){
		res.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
		res.write(JSON.stringify({"message": "Página v1 encontrada!"}));
	} else if(req.url === '/api/v2'){
		res.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
		res.write(JSON.stringify({"message": "Página v2 encontrada!"}));
	} else if(req.url === '/api/v3'){
		res.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
		res.write(JSON.stringify({"message": "Página v3 encontrada!"}));
	} else if(req.url === '/api/v4'){
		res.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
		res.write(JSON.stringify({"message": "Página v4 encontrada!"}));
	} else if(req.url === '/api/v5'){
		res.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
		res.write(JSON.stringify({"message": "Página v5 encontrada!"}));
	} else {
		res.writeHead(404, {'Content-Type': 'application/json; charset=utf-8'});
		res.write(JSON.stringify({"message": "Nenhuma página encontrada!"}));
  }
	res.end();
}).listen(3000, function(){
	console.log('Servidor rodando em localhost:3000');
});
```


text:
# NodeJS - Aula 02 - Exercício
**Autor:** Luan da Silva Oliveira
**User:** luanconecte

# 1 -  Quais são os 4 verbos que utilizamos para o CRUD?
+ POST   - CREATE
+ GET    - RETRIVE/READ
+ PUT    - UPDATE
+ DELETE - DELETE

# 2 - Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).

São códigos padrão de estado de uma aplicação, foram desenvolvidos para responder a uma requisição do cliente. O código é formado de três dígitos e separados em cinco grupos:

+ 1XX Informacional

Isso significa que o servidor recebeu os cabeçalhos da solicitação, e que o cliente deve proceder para enviar o corpo do pedido (no caso de haver um pedido um corpo deve ser enviado, por exemplo, um POST pedido). Se o corpo é grande o pedido, enviando-os para um servidor, quando o pedido já foi rejeitada com base em cabeçalhos inadequado é ineficiente. Para ter um cheque do servidor se o pedido pode ser aceite com base no pedido de cabeçalhos sozinho, o cliente deve enviar Esperar: 100-continue como um cabeçalho no seu pedido inicial e verifique se a 100 Continuar código de status é recebido em resposta antes de permanente (ou receber 417 Falha na expectativa e não continuar).

+ 2XX Sucesso

O servidor está entregando apenas parte do recurso devido a um cabeçalho intervalo enviados pelo cliente. O cabeçalho do intervalo é usado por ferramentas como wget para permitir retomada de downloads interrompidos, ou dividir um download em vários fluxos simultâneos.

+ 3XX Redirecionamento

Indica que o recurso não foi modificado desde o último pedido. Normalmente, o cliente fornece um cabeçalho HTTP como o Se-Modificado-Desde cabeçalho para proporcionar um tempo contra o qual para comparar. Usando este poupa largura de banda e de reprocessamento no servidor e cliente, uma vez que apenas os dados do cabeçalho devem ser enviados e recebidos em comparação com a totalidade da página que está sendo reprocessados pelo servidor, em seguida, enviado novamente utilizando mais largura de banda do servidor e cliente .

+ 4XX Erro do Cliente

A solicitação é maior do que o servidor está disposto ou capaz de processar.

+ 5XX Erro de Servidor

O servidor está em manutenção ou não consegue dar conta dos processamentos de recursos devido à sobrecarga do sistema. Isto deve ser uma condição temporária.

# 3 - Explique o que é cada parâmetro da função recebida no `createServer`.

A função recebe uma função de callback que recebe dois parâmetros:

request: Parâmetro que representa a requisição do cliente;
response: Parâmetro que representa a resposta do servidor;

# 4 - O que é e para que serve a Querystring?

Querystring é um conjunto de chave/valor passados através da URL:
htttp://127.0.0.1:3000?nome=Luan&idade=22&sexo=Masculino

No node através da função url.parser(request.url) conseguimos recuperar uma série de atributos que dizem respeito a URL da requisição, dentre eles o atributo query que trás um objeto com todos valores passados.

query: { nome: 'Luan', idade: '22', sexo: 'Masculino' },

# 5 - Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:

```js
// server.js

'use strict';

var http = require("http")
	, url = require('url');

const hostname = '127.0.0.1'
	, port = 1337
	, routes = [
		'/api/pokemons/create'
		, '/api/pokemons/read'
		, '/api/pokemons/update'
		, '/api/pokemons/delete'
	];

http.createServer((req, res) => {

	routes.forEach(function(element, index){
		if ( url.parse(req.url).pathname == element ) {
			res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });

			res.write(JSON.stringify({
				route: element
				, created_at: Date.now()
			}));
		}
	});

	res.end();

}).listen(port, hostname, () => {

	console.log(`Server running at http://${hostname}:${port}/`);

});
```


text:
# Node.js - Aula 02 - Exercício

**User:** [gkal19](https://github.com/gkal19)

**Autor:** Gabriel Kalani

## Quais são os 4 verbos que utilizamos para o CRUD?
C - Create
R - Retrieve/Read
U - Update
D - Delete

## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
As `Status Codes` foram criadas para responder uma requisição do cliente<br>

**(Informação)**
!['Cat'](https://http.cat/100)

**2(Sucesso)**
!['Cat2'](https://http.cat/200)

**3(Redirecionamento)**
!['Cat3'](https://http.cat/307)

**4(Erro de request)**
!['Cat4'](https://http.cat/402)

**5(Erro no servidor)**
!['That's fine'](https://http.cat/599)

## Explique o que é cada parâmetro da função recebida no `createServer`.
Request;
Response;

## O que é e para que serve a Querystring?
São variáveis e valores que são obtidos através de formulários ou requisições do usuário e que são enviados à url.
Nela podemos transferir dados do URL pelo GET.
`?campo=value&campo=value`

## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:

```js
const http = require('http');
http.createServer((req, res) => {
	res.writeHead(200, {'Content-Type': 'application/json;charset=utf-8'});
	switch(req.url){
		case '/create':
		createJson(res, 1, 'CREATE', req.url);
		break;
		case '/read':
		createJson(res, 2, 'READ', req.url);
		break;
		case '/update':
		createJson(res, 3, 'UPDATE', req.url);
		break;
		case '/delete':
		createJson(res, 4, 'DELETE', req.url);
		break;
		default:
		res.writeHead(404, {'Content-Type': 'application/json;charset=utf-8'});
		createJson(res, null, 'UM ERRO ENCONTRADO!!', req.url);
		break;
	}
	res.end();
}).listen(3000, () => {
	console.log('Servidor levantando na 3000');
});

function createJson(response, id, mensagem, url){
	const json = {
		'id': id,
		'mensagem': mensagem,
		'url': url,
		'data': new Date()
	};
	return response.write(JSON.stringify(json));
}
```


text:
# Node.js - Aula 02 - Exercício
**User:** [Geriel Castro](https://github.com/geriel)

**Autor:** Geriel Castro

**Date:**

#### 1 - Quais são os 4 verbos que utilizamos para o CRUD?
* **C** - `POST`
* **R** - `GET`
* **U** - `PUT`
* **D** - `DELETE`

#### 2 -  Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).

Para padronizar e facilitar o entendimento dos servidores, foi criado um padrão de Estatus ( *Status Codes* ), dessa forma, fica explícito os tipos de retorno que cada mensagem vem do servidor.

#### 1XX Informacional
###### 100 - Continue

![](https://http.cat/100)

#### 2XX Sucesso

###### 206 - Partial Content

![](https://http.cat/206)

#### 3XX Redirecionamento

###### 304 - Not Modified

![](https://http.cat/304)

#### 4XX Erro do Cliente

###### 409 - Conflict

![](https://http.cat/409)

#### 5XX Erro de Servidor

###### 502 - Bad Gateway

![](https://http.cat/502)

#### 3 - Explique o que é cada parâmetro da função recebida no `createServer`.

* **Request** - Parâmetro que contém a requisição do usuário.

* **Response** - Servidor utiliza como resposta para usuário.

#### 4 - O que é e para que serve a Querystring?

É a maneira utilizada para passar parametros para outras páginas através da URL. Utilizamos ela com o metodo `GET`.

#### 5 - Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:

* /api/pokemons/create
* /api/pokemons/read
* /api/pokemons/update
* /api/pokemons/delete

```js

'use strict';

var date = (new Date()).toJSON();

const http = require('http')
    , SUCCESS = {
        version: 1.0
        , name: 'Geriel Castro - Be Mean'
        , created_at: date
    }
    , ERROR = {
        message: "Não Encontrada"
    }
    ;

http.createServer(function(req, resp){
    var url = req.url;

    switch(url){
        case "/api/pokemons/create":
            resp.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
            resp.write(JSON.stringify(SUCCESS));
        break;
        case "/api/pokemons/read":
            resp.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
            resp.write(JSON.stringify(SUCCESS));
        break;
        case "/api/pokemons/update":
            resp.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
            resp.write(JSON.stringify(SUCCESS));
        break;
        case "/api/pokemons/delete":
            resp.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
            resp.write(JSON.stringify(SUCCESS));
        break;

        default:
            resp.writeHead(404, {'Content-Type': 'application/json; charset=utf-8'});
            ERROR.message = "Pagina não encontrada!";
            p.write(JSON.stringify(ERROR));
            break;
    }
    resp.end();
})
.listen(3000, function(){
    console.log('Servidor rodando em localhost:3000');
});

```