text:
# NodeJs - Exercício 02 - resolvido

autor: Carlos Alberto Araujo Barreto

## 01 - Quais são os 4 verbos que utilizamos para o CRUD?
Create: Criar - **POST**
Retrieve/Read: Recuperar/Ler - **GET**
Update: Atualizar - **PUT**
Delete: Deletar - **DELETE**

## 02 - 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 foram desenvolvidos para padronizar os retornos de requisições HTTP.

100 - Continuar: o servidor que recebeu os cabeçalhos da solicitação, e que o cliente deve proceder para enviar o corpo do pedido.
![Erro 100](https://http.cat/100)

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

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

409 - Conflito: Indica que a solicitação não pôde ser processada por causa do conflito no pedido, como um conflito de edição.
![Erro 409](https://http.cat/409)

503 - Serviço indisponível: 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.
![Erro 503](https://http.cat/503)

## 03 - Explique o que é cada parâmetro de função recebida no 'createServer'.

Recebe uma função anônima como parâmetro com os seguintes argumentos:

### Request
Dados da requisição feita pelo usuário

### Response
Dados do callback que será retornado para o usuário

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

É a string que contém os valores recebidos via query na URL.
Ela serve para passar informações através das páginas usando o método GET.

## 05 - 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')
, SUCESSO = {message: 'Be-Mean NodeJS', responseDate: date}
, ERRO = {message: 'Página não encontrada', responseDate: date};

http.createServer(function(request, response){

	switch(request.url){
		case '/api/caso1':
			response.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
			response.write(JSON.stringify(SUCESSO));
			break;
		case '/api/caso2':
			response.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
			response.write(JSON.stringify(SUCESSO));
			break;
		case '/api/caso3':
			response.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
			response.write(JSON.stringify(SUCESSO));
			break;
		case '/api/caso4':
			response.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
			response.write(JSON.stringify(SUCESSO));
			break;
		default:
			response.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
			response.write(JSON.stringify(ERRO));
	}
	response.end();
}).listen(3000, function(){
	console.log('Servidor rodando em localhost: 3000');
});

```


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

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

**autor:** Gilson da Silva Borges Filho

**date:** 1457204474567

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

**GET**: Verbo usado para listar todos os recursos disponíveis de uma rota específica
ou então de um recurso selecionado. Exemplo:

```bash
GET /products - Lista todos os produtos
GET /products/1 - Retorna o produto de número 1
```

**POST**: Verbo usado para criar um novo recurso no servidor. Dependendo da necessidade,
ele é usado também para atualizar um recurso existente.

```bash
POST /products - Cria um novo recurso de produto no servidor
POST /products/1 - Atualiza um produto do servidor
```

**PUT**: Verbo usado para atualizar um recurso no servidor.

```bash
PUT /products/1 - Atualiza os dados de um recurso selecionado
```

**DELETE**: Remove um recurso armazenado no servidor.

```bash
DELETE /products/1 - Remove o recurso "Produto 1" no servidor
```

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

Foram criados para definir o status do processamento do servidor, se foi de sucesso ou erro por exemplo.
Ele possui um padrão no formato desse código. Dentro do status code, temos alguns grupos como:

#### 1xx - Informacional

Traz informações do que foi feito no processamento. Ele não é muito usado atualmente.

Exemplo:
 - 100 CONTINUE: Solicita que o cliente continue com a requisição feita, já que
 a primeira parte dela já foi recebida.
 ![Status Code 100](https://http.cat/100)

#### 2xx - Sucesso

Esse grupo indica que a requisição feita pelo cliente foi executado, recebido ou aceito com sucesso.

Exemplo:
 - 200 OK: A requisição foi aceita
 ![Status Code 200](https://http.cat/200)
 - 201 CREATED: A requisição foi aceita e resultou em um novo recurso.
 ![Status Code 201](https://http.cat/201)

#### 3xx - Redirecionamento

Aqui é quando uma ação que precisa ser feito para que ocorra um redirecionamento de
um recurso para outro.

Exemplo:
 - 301 MOVED PERMANENTLY: Efetua um redirecionamento completo, mudando a URI
 ![Status Code 301](https://http.cat/301)
 - 304 NOT MODIFIED: Quando efetua alguma requisição de alguma informação, mas
 ![Status Code 304](https://http.cat/304)
 que não houve nenhuma mudança. Ocorre muito em arquivos estáticos.

#### 4xx - Erro no Cliente

Nesse grupo possui códigos que identificam erros cometidos pelo cliente.

Exemplo:
 - 404 NOT FOUND: Recurso solicitado não encontrado
 ![Status Code 404](https://http.cat/404)
 - 400 BAD REQUEST: A requisição construida possui algum erro que não é possivel
 ![Status Code 400](https://http.cat/400)
 ser aceito.

#### 5xx - Erro no Servidor

Diferente do último, são códigos de define os tipos de erros cometidos pelo servidor.

Exemplo:
 - 500 INTERNAL SERVER ERROR: Indica que ocorreu algum erro no processamento do servidor,
 ![Status Code 500](https://http.cat/500)
 impossibilitando uma resposta esperada.
 - 505 HTTP VERSION NOT SUPPORTED: Quando alguma requisição é feito usando determinada
 versão do protocolo HTTP que o servidor não tem suporte para processá-la.

## Explique o que é cada parametro da função recebida no `createServer`.

Dentro do createServer você manda uma função anônima com dois parametros:

 - request: O objeto que possui a requisição do cliente;
 - response: Resposta a ser montada pelo servidor e enviado ao cliente.

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

Querystring um formato para recebimendo de valores na url. Segue um exemplo:

```
http://host.com/routername?param1=value1&param2=value2o
```

Assim você o servidor recebe na requisição dessa URL:

chave: param1
valor: value1

chave: param2
valor: value2

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

```javascript
'use strict';

const json_head = {'Content-Type': 'application/json'};

const http = require('http')
	, SUCCESS = {
			message: 'Its success',
		, status: 200
	}
	, ERROR = {
			message: 'Its not found'
		, status: 404
	}
	;

var render_success = function(req, res) {
	res.writeHead(200, json_head);
	res.write(JSON.stringify(SUCCESS));
};

var render_error = function(req, res) {
	res.writeHead(404, json_head);
	res.write(JSON.stringify(ERROR));
};

var server = http.createServer(function(req, res) {
		if(req.url === '/router/a') {
			render_success(req, res);
		}
		else if(req.url === '/router/b') {
			render_success(req, res);
		}
		else if(req.url === '/router/c') {
			render_success(req, res);
		}
		else if(req.url === '/router/d') {
			render_success(req, res);
		}
		else {
			render_error(req, res);
		}
});
```

repo_language: JavaScript

mime_type: text/plain


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

autor: Bruno Lima da Silva

## 1. Quais são os 4 verbos que utilizamos para o CRUD?
C - Create - Post (Criar)
R - Retrieve/Read - Get (Ler)
U - Update - Put (Atualizar)
D - Delete - Delete (Deletar)

## 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 foram inventados para que toda requisição feita possa receber um código de resposta e padronizar o retorno do servidor, onde com esse código é possivel saber se uma operação foi realizada com sucesso, se foi movide ou se não foi encontrada.
- 101 Switching Protocols (Mudando protocolos): Isso significa que o solicitante pediu ao servidor para mudar os protocolos e o servidor está reconhecendo que irá fazê-lo.
https://http.cat/101
- 201 Create (Criado): O pedido foi cumprido e resultou em um novo recurso que está sendo criado.
https://http.cat/201
- 304 Not Modified (Não modificado): O recurso não foi alterado.
https://http.cat/304
- 403 Forbidden (Proibido): O servidor entende a requisição, mas se recusa em atendê-la. O cliente não deve tentar fazer uma nova requisição.
https://http.cat/403
- 503 Service Unavailable (Servidor indisponível): O servidor não é capaz de processar a requisição pois está temporariamente indisponível.
https://http.cat/503

## 3. Explique o que é cada parâmetro da função recebida no `createServer`.
Request: Request é a requisição que o usuário está fazendo para o servidor
Response: Response é a resposta que o servidor está retornando para a requisição do usuário.

## 4. O que é e para que serve a Querystring?
QueryString é um modelo clássico de manutenção do estado da página. É composto porque chaves e valores anexados na URL.
Serve para passar parâmetros para o servidor através do método GET.

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

```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: 'Não encontrado'
};

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


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

**user:** [joseasousa](https://github.com/joseasousa/)
**autor:** Jose Alves De Sousa Neto

## 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 `statos code` é uma das informações que vem na resposta, onde e definido o resultado da requisição

### 101 Mudando protocolos
Isso significa que o solicitante pediu ao servidor para mudar os protocolos e o servidor está
reconhecendo que irá fazê-lo. 102 Processamento Como uma solicitação WebDAV pode conter muitos
sub-pedidos que envolvam operações de arquivo,
pode demorar muito tempo para concluir o pedido. Este código indica que o servidor recebeu e está
processando o pedido, mas nenhuma resposta ainda não está disponível. Isso impede que o cliente o
tempo limite e supondo que o pedido foi perdido.

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

### 206 Conteúdo parcial
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.

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

### 305 Use Proxy (desde HTTP/1.1)
Muitos clientes HTTP (como o Mozilla e Internet Explorer) podem não tratar corretamente as
respostas com este código de status, principalmente por razões de segurança.

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

### 402 Pagamento necessário
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.

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

### https://http.cat/502
Em regra, o erro quando há uma configuração imprecisa entre os computadores de back-end,
possivelmente incluindo o servidor Web no site visitado. Antes de analisar este problema,
é necessário limpar o cache do navegador, completamente.
Se estiver navegando na Web e observar este problema em todos os websites visitados, então 1)
o seu provedor de serviço de Internet tem uma falha/sobrecarga em um equipamento principal ou 2)
tem algo de errado com a sua conexão interna à Internet, por exemplo, o firewall não está
funcionando corretamente. Se for o primeiro caso, somente o seu provedor pode ajudar. Se for
o segundo, você precisa corrigir o que quer que esteja prevenindo que você acesse a Internet.
Se tiver este problema somente em alguns websites visitados, provavelmente existe um problema
nos sites. Por exemplo, uma das peças dos equipamentos estão falhando ou estão sobrecarregadas.
Entre em contato com os responsáveis destes sites.

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

## Explique o que é cada parâmetro da função recebida no `createServer`.
ele recebe uma função anonima com 2 parametros request e response

`request`: recebe informação da solicitação feita ao servidor

`response`: é a resposta dada para a 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
var date = (new Date()).toJSON();

const http = require('http')
    , SUCCESS = {
        version: '1.0'
        , name: 'BE MEAN'
        , returned_at: date.toString().
            replace(/T/, ' ').
            replace(/\..+/, '')
    }
    , ERROR = {
        message: 'Rota Inexistente'
    }

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

    success = () => {
        res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
        res.write(JSON.stringify(SUCCESS));
    }

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

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

        case '/api/r2':
            success();
            break;

        case '/api/r3':
            success();
            break;

        case '/api/r4':
            success();
            break;

        default:
            error();
            break;
    }

    res.end();
}).listen(3000, () => {
    console.log('Servidor rodando na porta 3000')
});
```


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

**autor:** Airton Vancin Junior

## 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 - 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`.

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

- 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:** [PabloDinella](https://github.com/PabloDinella/)
**autor:** Pablo Rocha Dinella
**date:** 1453992406579

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

|CRUD      | HTTP   |
|----------|--------|
|Create    | POST   |
|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/).

Para informar qual o retorno do servidor.

### 100 - Switching protocols

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

### 202 - Accepted

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

### 307 - Temporary Redirect

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

### 414 - Requested URI too long

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

### 507 - Insuficient storage

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

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

São dois parâmetros:

**request**
-	Objeto que contém informações relacionadas à requisição do cliente, como o cabeçalho http, url, etc.

**response**
-	Objeto que contém informações relacionadas à resposta ao cliente.

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

É uma parte da URL, que tem informação em forma de pares de chave/valor que o cliente envia ao servidor.

Exemplo: `http://www.google.com/pagina?chave=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')
		, SUCESS = {
			version: 1.0
			, name: 'Be MEAN é nóis'
			, created_at: date
		}
		, ERROR = {
				message: 'Deu ruim! Não encontrado...'
			}
		;

http.createServer(function(req, res){
	if (req.url === '/api/v1') {
		res.writeHead(200,{'Content-Type':'application/json; charset=utf-8'});
		res.write(JSON.stringify(SUCESS));
	}
	else if (req.url === '/api/v1b') {
		res.writeHead(200,{'Content-Type':'application/json; charset=utf-8'});
		res.write(JSON.stringify(SUCESS));
	}
	else if (req.url === '/api/v1c') {
		res.writeHead(200,{'Content-Type':'application/json; charset=utf-8'});
		res.write(JSON.stringify(SUCESS));
	}
	else if (req.url === '/api/v1d') {
		res.writeHead(200,{'Content-Type':'application/json; charset=utf-8'});
		res.write(JSON.stringify(SUCESS));
	}
	else {
		res.writeHead(404,{'Content-Type':'application/json; charset=utf-8'});
		res.write(JSON.stringify(ERROR));
	}
	res.end()
}).listen(3000, function(){
	console.log('Server rodando em localhost:3000');
});
```


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

**Autor:** Mauricio Gravena de Oliveira
**Data:** 01/09/2016

## 1. Quais são os 4 verbos que utilizamos para o CRUD?
 Create | Read | Update | Delete

## 2. Para que foram invetados os Staus Code? Dê exemplos de 1 código por grupo e a imagem do Cat Status Code.

Foram inventados para ajudar no diagnótico da troca de mensagens pelo protocolo HTTP.

###  **Success 1xx**
#### **Switching Protocols 101**
![Switching Protocols 101](https://http.cat/101 "Switching Protocols 101")

###  **Success 2xx**
#### **CREATED 201**
![CREATED 201](https://http.cat/201 "CREATED 201")

### **Error 4xx, 5xx**
#### **Internal Error 500**
![Internal Error 500](https://http.cat/500 "Internal Error 500")

### **Redirection 3xx**
#### **Not Modified 304**
![Not Modified 304](https://http.cat/304 "Not Modified 304")

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

O "req"(request) é reponsável por tratar o pedido do cliente, já o "res"(response) devolve uma reposta baseada no pedido.

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

É uma módulo nativo, que fornece métodos para tratamento e formatação de URL

## 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');

const SUCCESS = {
  version: 1.0,
  name: 'Be Mean',
  created_at: date
};

const ERROR = {
  message: "Não encontrado!"
};

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

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

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

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

const err = (res) => {
  res.writeHead(404, {
    'Content-Type': 'application/json'
  });
  res.write(JSON.stringify(ERROR));
}

var server = http.createServer((req, res) => {
  let url = req.url;

  switch(url) {

    case '/api/pokemons/create':
      create(res);
      break;

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

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

    case '/api/pokemons/delete':
      del(res);
      break;

    default:
      err(res);
      break;
  }
  res.end();
}).listen(3000, () => {
  console.log('Servidor rodando... localhost:3000');
});
```


text:
# Node.js - Aula 02 - Exercício
####Robson Fagundes - [https://robsonfagundes.github.io](robsonfagundes.github.io) - robsonfagundes@gmail.com

## 1. Quais são os 4 verbos que utilizamos para o CRUD?
- **C**reate - Criar ou adicionar novas entradas = `POST`
- **R**ead (**R**etrieve) - Ler, recuperar ou ver entradas existentes = `GET`
- **U**pdate - Atualizar ou editar entradas existentes = `PUT`
- **D**elete (**D**estroy) - Remover entradas existentes = `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 inventados para padronizar os tipos de retorno do servidor, facilitando o entendimento deles.

* **1XX** - Information

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

* **2XX** - Successful

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

* **3XX** - Redirection

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

* **4XX** - Client Error

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

* **5XX** - Server Error

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

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

Os parâmetros recebidos pelo **createServer** são: request e response. A definição de ambos é bem simples, **Request** é a informação chegando no servidor através do navegador (Input), já o **Response** é a informação chegando no navegador através do servidor (Output).

Principais propriedades de cada um desses objetos:

**Request:**
- Corpo do HTTP response;
- Número de Bytes enviados pelo cliente;
- Coleção de cabeçalhos;
- Porta servidor utilizada;
- Estado do servidor;
- Nome do servidor;
- Verificação de conexão SSL.

**Response:**
- Corpo do request HTTP;
- Código da página para o corpo Request;
- Versão do HTTP;
- Caminho do HTTP;
- Tamanho do Buffer;

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

Na Web, uma **Querystring** ou string de consulta, é a parte de um Uniform Resource Locator (URL) que contém dados que não se encaixa convenientemente em uma estrutura hierárquica do caminho. A querystring inclui campos comumente adicionados a uma base URI por um navegadores ou por uma aplicação, por exemplo, como parte de um formulário HTML.

#####Exemplo de URL contendo uma querystring:
http://example.com/be-mean-instagram/node?name=aula2

 - Quando um servidor recebe um pedido de uma página web, ele pode executar uma ação ou evento, passando a querystring, que neste caso é **`name=aula2`**. O ponto de interrogação **`.../node?`** é usado como um separador para informar a URL que há uma querystring mas não faz parte da string de consulta.

## 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();

var http = require('http'),
	SUCCESS = {
		version: 'NodeJS - Exercício 0.2',
	  	name: 'WebSchool.io/be-mean-instagram-nodejs-exercises/class-02',
	  	returned_at: date
	},
	ERROR = {
	  	message: "request 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('Server be-mean-instagram Node running on 127.0.0.1:3000');
});

```

```
robsonfagundes@Dell-3500:/media/robsonfagundes/SSD-Dados/Personal Projects/WebSchool.io/be-mean-instagram-nodejs-exercises/class-02$ node server
Server be-mean-instagram running on 127.0.0.1:3000
```
[![server.js class 2 em ação](https://raw.githubusercontent.com/robsonfagundes/be-mean-instagram-nodejs-exercises/master/class-02/img/class2.png)](https://raw.githubusercontent.com/robsonfagundes/be-mean-instagram-nodejs-exercises/master/class-02/img/class2.png "server.js class 2 em ação")


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

**Autor:** Wendell Adriel Luiz Silva - [WendellAdriel](https://github.com/WendellAdriel)
**Data:** 1455123299354

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

- **Create:** `POST`
- **Retrieve:** `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).

Foram inventados a fim de padronizar os retornos possíveis utilizados por servidores.

- **1XX:** Códigos de informação
![100](https://http.cat/100.jpg)

- **2XX:** Códigos de sucesso
![202](https://http.cat/202.jpg)

- **3XX:** Códigos de redirecionamento
![301](https://http.cat/301.jpg)

- **4XX:** Códigos de erro do `cliente`
![409](https://http.cat/409.jpg)

- **5XX:** Códigos de erro do `servidor`
![507](https://http.cat/507.jpg)

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

- **request:** parâmetro com todos dados da requisição feita pelo usuário.
- **response:** parâmetro com métodos utilizados para devolver uma resposta ao usuário.

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

- **O que é:** uma parte da URL que contém um ou mais parâmetros passados como `chave=valor`.
- **Para que serve:** para passar dados (parâmetros) necessários 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 now = (new Date()).toJSON();

const http = require('http')
    , API_ROUTE = '/api/pokemons/'
    , SUCCESS = {
        message : 'Route OK'
      , returned_at : now
      }
    , ERROR = {
        message : 'Warning: Route NOT OK!!!'
      , returned_at : now
    };

http.createServer(function(req, res) {
  switch(req.url) {
    case API_ROUTE + 'create':
    case API_ROUTE + 'read':
    case API_ROUTE + 'update':
    case API_ROUTE + 'delete':
      res.writeHead(200, { 'Content-Type' : 'application/json' });
      res.write(JSON.stringify(SUCCESS));
      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');
});
```


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

**Autor:** Matheus José Krumenauer Weber

**Date:** 1456532077731

## Quais são os 4 verbos que utilizamos para o CRUD?
Post para o create, get para o retrieve, put para o update e delete para o 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 - Informação

- 2xx - Sucesso

- 3xx - Redirecionamento

- 4xx - Erro no lado do cliente

- 5xx - Erro no lado do servidor

## Explique o que é cada parâmetro da função recebida no `createServer`.
Request que possui os parâmetros utilizados na requisição do usuário e Response que possui os métodos utilizados para o envio de respostas ao usuário.

## O que é e para que serve a Querystring?
São valores passados após o nome da url, servem para passar parametros de uma página para outra.

## 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){
  if(req.url === '/api/v1') {
    res.writeHead(200, {'Content-Type': 'application/json'});
    res.write(JSON.stringify(SUCCESS));
  } else if (req.url === '/api/v2'){
        res.writeHead(204, {'Content-Type': 'application/json'});
        res.write(JSON.stringify(SUCCESS));
  }else if (req.url === '/api/v3'){
        res.writeHead(200, {'Content-Type': 'application/json'});
        res.write(JSON.stringify(SUCCESS));
  }
  else {
    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:** [hc3](https://github.com/hc3)
**autor:** Eliel das Virgens
**date:** 20/03/2015

##01.Quais são os 4 verbos que utilizamos para o CRUD
-CREATE , READ , UPDATE , DELETE.

##02.Para que foram inventados os status codes? de um exemplo de 1 código por grupo e a imagem do cat Status Code.

-Servem para padronizar erros que acontecem

### 100 - Switching protocols

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

### 202 - Accepted

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

### 307 - Temporary Redirect

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

### 414 - Requested URI too long

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

### 507 - Insuficient storage

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

##03.Explique o que é cada parâmetro da função recebida no createServer
-Request métodos para lidar com a requisição do cliente
-Response métodos para lidar com a resposta do servidor

##04.Oque é e para que serve a QueryString
é um conjunto de chave valor anexado a URL e com ela podemos passar parametros para o servidor

##05.Escreva o 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
    , code: 200
    , name: 'MEAN'
    , created_at: date
    }
  , ERROR = {
      message: "DEU MERDA"
    , code: 405
    };

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

    switch(url){
        case "/api/cliente/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/cliente/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/cliente/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/cliente/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:** [diegolopesdev](http://github.com/diegolopesdev)
**autor:** Diego Lopes do Nascimento

## Quais são os 4 verbos que utilizamos para o CRUD?
* C - Create - Criar (POST)
* R - Retrieve / Read - Recuperar / Ler (GET)
* U - Update - Atualizar (PUT)
* D - Delete - Deletar (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 informar e padronizar o retorno das requisições HTTP entre o Cliente e o Servidor.

Exemplo de retorno do 100: https://http.cat/100 [100](https://http.cat/100)
![Exemplo de imagem 100](https://http.cat/100 "Exemplo de imagem 100")

Exemplo de retorno do 201: https://http.cat/201 [201](https://http.cat/201)
![Exemplo de imagem 201](https://http.cat/201 "Exemplo de imagem 201")

Exemplo de retorno do 301: https://http.cat/301 [301](https://http.cat/301)
![Exemplo de imagem 301](https://http.cat/301 "Exemplo de imagem 301")

Exemplo de retorno do 404: https://http.cat/404 [404](https://http.cat/404)
![Exemplo de imagem 404](https://http.cat/404 "Exemplo de imagem 404")

Exemplo de retorno do 500: https://http.cat/500 [500](https://http.cat/500)
![Exemplo de imagem 500](https://http.cat/500 "Exemplo de imagem 500")

## Explique o que é cada parâmetro da função recebida no `createServer`.
A função *createServer*, do módulo HTTP, recebe uma função anônima que possui dois parâmetros: req (request) e res (response) e que retorna um objeto da classe *EventEmitter*.

*request* - É uma instância da classe *http.IncomingMessage* e possui informações sobre a requisição feita ao servidor.
*response* - É uma instância da classe *http.ServerResponse* e é responsável por manipular a resposta que será enviada ao cliente.

## O que é e para que serve a Querystring?
*QueryString* é um padrão que o protocolo HTTP utiliza para transporte de informações do cliente para o servidor, como um conjunto de valores anexados a URL através de uma requisição GET.

Exemplo: http://www.meusite.com/pokemon/search?name=Mea&limit=10.

O servidor receberá uma requisição que contém duas variáveis nessa requisição: *Name* e *Limit*. Nesse exemplo, eu poderia listar na pesquisa todos os pokémons que começam com "Mea" e limitando o resultado em 10 items.

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

```

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', 'Você está criando um Pokémon.');
      break;
      case '/api/pokemons/read':
         setStatus('READ', 'Você está retornando um Pokémon.');
      break;
      case '/api/pokemons/update':
         setStatus('UPDATE', 'Você está atualizando um Pokémon.');
      break;
      case '/api/pokemons/delete':
         setStatus('DELETE', 'Você está 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.');
});

```

## Envio

[Veja na nossa Wiki](https://github.com/Webschool-io/be-mean-instagram/wiki/Exerc%C3%ADcios)

1. Crie o repositório específico do módulo. Ex.: be-mean-instagram-nodejs
2. Crie a solução do exercício localmente nesse repositório, usando sempre o padrão `class-X-resolved-githubuser-Nome-Completo-Com-Hifens-Nos-Espaços.md`
3. Dê um `fork` no repositório oficial [https://github.com/Webschool-io/be-mean-instagram-nodejs-exercises](https://github.com/Webschool-io/be-mean-instagram-nodejs-exercises)
4. Vá até a pasta do módulo desejado e **COLE** seu arquivo na pasta `exercises`
5. Execute um `git add NOME_DO_SEU_ARQUIVO.md` depois o `git commit -m 'SEU NOME - Node.js - Exercicio X resolvido'`
5. Crie um **Pull Request** enviando **APENAS** o seu arquivo sem modificar mais nada.
6. Na mensagem do commit/pull request favor seguir o padrão: Nome Completo - Node.js - Exercicio X resolvido
7. Levante as mão para o céu e agradeça se acaso tiver ... #brinks


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

**autor:** Vinicius Moreira Mazzeo

## 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/).

O Status Codes foram inventados para identificar o retorno do servidor, para identificar qual o status dele.
Estes códigos são formados por 3 dígitos por padrão.

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

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

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

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

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

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

`createServer` é uma função anônima, é uma caracterísca importante do JavaScript, ela responde para o cliente que fez a requisição.
Ela é executada apenas neste momento.

- request: requisições feitas pelo cliente;
- response: respostas do servidor para o cliente.

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

Querystring é como podemos passar os valores através da url, com isso podemos capturar estes valores através desta mesma url.

## 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')
    , SUCCESS = {
        name: '<h1>É TEEETRAAAAAAAA</h1>',
    }
    , ERROR = {
        message: "<h1>Não foi dessa vez!</h1>"
    };

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

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

    switch (req.url) {
        case rota[0]:
        case rota[1]:
        case rota[2]:
        case rota[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, function(){
    console.log('Servidor rodando em localhost:3000');
});

```


text:
# NodeJS - Aula 02 - Exercício
**Autor**: Igor luíz
**Github**: [Halfeld](https://github.com/Halfeld)
**Data**: 1456024583434

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

+ C = GET
+ R = POST
+ 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_

Para a identificação correta de retorno.

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

##### 204
![erro 204](https://http.cat/204)

##### 303
![erro 303](https://http.cat/303)

##### 402
![erro 402](https://http.cat/402)

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

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

+ **request**: Requisição feita pelo navegador.
+ **response**: Resposta para o navegador.

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

É um protocolo que é usando para transportar dados entre cliente e o servidor.

#### 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');

const SUCCESS = {
    version: 1.0,
    name: 'Be MEAN',
    created_at: date
};

const 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:** [Pauloxt1](https://github.com/Pauloxt1)

**Autor:** Paulo Roberto

## Quais são os 4 verbos que utilizamos para o CRUD?
Create
```js
 // Exemplo create com mongoDB
  Paulo(mongod-3.2.1) test> use crud
  switched to db crud
  Paulo(mongod-3.2.1) crud> db.users.insert({nome:'Paulo', senha:123})
  Inserted 1 record(s) in 238ms
  WriteResult({
    "nInserted": 1
  })
```
Read
```js
  // Exemplo read com mongoDB
  Paulo(mongod-3.2.1) crud> db.users.find()
  {
    "_id": ObjectId("56996261515cfa181e3a3e8d"),
    "nome": "Paulo",
    "senha": 123
  }
```
Update
```js
  // Exemplo update com mongoDB
  Paulo(mongod-3.2.1) crud> db.users.update({nome:'Paulo'},{$set:{senha:321}});
  Updated 1 existing record(s) in 3ms
  WriteResult({
    "nMatched": 1,
    "nUpserted": 0,
    "nModified": 1
  });
```
Delete
```js
  Paulo(mongod-3.2.1) crud> db.users.remove({})
  Removed 1 record(s) in 1ms
  WriteResult({
    "nRemoved": 1
  })
```
## 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 as respostas vinda do servidor.

1(Informação):

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

2(Sucesso):

!['That's fine'](https://http.cat/200)

3(Redirecionamento):

!['That's fine'](https://http.cat/307)

4(Erro de request):

!['That's fine'](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: Objeto com as informações da requisição feita pelo cliente.

Response: Objeto responsável por gera a resposta do servidor para o cliente.

## O que é e para que serve a Querystring?
É uma forma de passa dados via URL pelo GET, seguem o seguinte padrão `?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(function(req,res){
	res.writeHead(200, {'Content-Type': 'application/json;charset=utf-8'});
	switch(req.url){
		case '/create':
		createJson(res, 1, 'Parte de create do CRUD', req.url);
		break;
		case '/read':
		createJson(res, 2, 'Parte de read do CRUD', req.url);
		break;
		case '/update':
		createJson(res, 3, 'Parte de update do CRUD', req.url);
		break;
		case '/delete':
		createJson(res, 4, 'Parte de delete do CRUD', req.url);
		break;
		default:
		res.writeHead(404, {'Content-Type': 'application/json;charset=utf-8'});
		createJson(res, null, 'Ação de CRUD não encontrada', req.url);
		break;
	}
	res.end();
}).listen(3000, function(){
	console.log('Servidor levantando na 3000');
});

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


text:
# Node.js - Aula 02 - Exercício
**User:** ronal2do
**Author:** Ronaldo Lima
**Date:**  1468002892280

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

* C - Create - Criar
* R - Read ou Retrieve - Ler ou Recuperar
* U - Update - 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).

Os Status Codes foram criado  para informar o atendimento ou não da requisição HTTP:

  * Informação.
    - 101 (Mudando protocolos): Isso significa que o solicitante pediu ao servidor para mudar os protocolos e o servidor está reconhecendo que irá fazê-lo. 102 Processamento (WebDAV) (RFC 2518) Como uma solicitação WebDAV pode conter muitos sub-pedidos que envolvam operações de arquivo, pode demorar muito tempo para concluir o pedido. Este código indica que o servidor recebeu e está processando o pedido, mas nenhuma resposta ainda não está disponível. Isso impede que o cliente o tempo limite e supondo que o pedido foi perdido. Cat Status Code (https://http.cat/101).

  * Sucesso.
    - 202 (Aceito):O pedido foi aceito para processamento, mas o tratamento não foi concluído. O pedido poderá ou não vir a ser posta em prática, pois pode ser anulado quando o processamento ocorre realmente. Cat Status Code  (https://http.cat/202).

  * Redirecionamento.
    - 304 (Não modificado ): 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. Cat Status Code (https://http.cat/304).

  * Erro do cliente.
    - 409 (Conflito): Indica que a solicitação não pôde ser processada por causa do conflito no pedido, como um conflito de edição. Cat Status Code (https://http.cat/409).

  * Erro do servidor.
    - 500 (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/500).

[fonte Wikipedia](https://pt.wikipedia.org/wiki/Lista_de_c%C3%B3digos_de_status_HTTP)

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

*  O parâmetro `request` recebe os dados da requisição.
*  O parâmetro `response` retorna como callback os dados da requisição.

## O que é e para que serve a `QueryString`?

Querystring é a maneira utilizada para passarmos parametros para outras páginas através da barra de endereços sem a necessidade de um formulário.

Exemplos de uso

`localhost:3000/teste?name=Suissa` ou `http://www.site.com?query=Parametro`

Sendo que podemos concatenas mais parametros com o uso do `&`.
Ex. `http://www.site.com?query=Key&otherQuery=OtherKey&more=One`
Saída:
*  query: Key
*  otherQuery: OtherKey
*  more: One

## 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;
  switch(url){
      case "/api/pokemons/create" :
          response.writeHead(200,
              {'Content-Type': 'application/json; charset=utf-8'});
              response.end(JSON.stringify(
          [SUCCESS, {info: "Create: Ok"}]));
      break;
      case "/api/pokemons/update" :
          response.writeHead(200,
              {'Content-Type': 'application/json; charset=utf-8'});
              response.end(JSON.stringify(
          [SUCCESS, {info: "Update: Ok"}]));
      break;
      case "/api/pokemons/read" :
          response.writeHead(200,
              {'Content-Type': 'application/json; charset=utf-8'});
              response.end(JSON.stringify(
          [SUCCESS, {info: "Retrieve: Ok"}]));
      break;
      case "/api/pokemons/delete" :
          response.writeHead(200,
              {'Content-Type': 'application/json; charset=utf-8'});
              response.end(JSON.stringify(
          [SUCCESS, {info: "Delete: Ok"}]));
      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:** [Marcos](https://github.com/marks88martinez)

**autor:** Marcos Antonio Martinez Florentin

## 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 a comunicação entre cliente e servidor, sabendo assim qual é a resposta que ela retorna.

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

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

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

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

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

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

#Request:
Requisição feita pelo cliente;
#Response:
Resposta do servidor para o cliente.

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

Usada normalmente para armazenar valores de variáveis, tais valores são armazenados no final da 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'),
V1 = {
  version:'1.0',
  name:'Rota1',
  created_at: date
},V2 = {
  version:'2.0',
  name:'Rota2',
  created_at: date
},V3 = {
  version:'3.0',
  name:'Rota3',
  created_at:date
},V4 = {
  version:'4.0',
  name:'Rota4',
  created_at:date
},ERROR = {
  message : "DEU MERDA FI!!!!"
  };

  http.createServer(function(req, res){

    switch (req.url) {
      case '/api/v1':
      res.writeHead(200, {'Content-Type':'application/json'});
      res.write(JSON.stringify(V1));
      break;
      case '/api/v2':
      res.writeHead(200, {'Content-Type':'application/json'});
      res.write(JSON.stringify(V2))
      break;
      case '/api/v3':
      res.writeHead(200, {'Content-Type':'application/json'});
      res.write(JSON, stringify(V3));
      break;
      case '/api/v4':
      res.writeHead(200, {'Content-Type':'application/json'});
      res.write(JSON.stringify(V4));
      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 esta funcionando en localhost:3000');
  });

```


text:
# Node.js - Aula 02 - Exercício
**user:** [maurienefirmino](https://github.com/maurienefirmino)
**autor:** Mauriene Firmino do Nascimento Júnior
**date:** 1474200477235

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

Para o Create = verbo POST.
Para o Reatrive/Read = verbo GET.
Para o Update = verbo PUT.
Para o Delete = verbo 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/).

Foram inventados para existir um feedback para o cliente sobre o que acontece nas requisiçõs.

#### 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

#### 201 - Criado
![Criado](https://http.cat/201)
A requisição gerou um novo registro.

#### 301 - Movido permanentemente
![Movido permanentemente](https://http.cat/301)
A url requisitada não está disponivel na mesma.

#### 401 - Não autorizado
![Não Autorizado](https://http.cat/401)
O conteúdo requisitado necessita de alguma autenticação.

#### 500 - Erro interno no servidor
![Erro interno no servidor](https://http.cat/500)
Erro que pode significar diversos erros internos.

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

Resquest = É um objeto que armazena os dados da requisição do cliente.
Response = É um objeto callback que será retornado para o cliente que fez a requisição.

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

É uma maneira de se passar dados usando a url. Usando `?` seguido das proriedades e dos valores, sendo que quando se tem mais de uma propriedade usa-se `&` para concatenar-los.

Ex.: http://localhost/api/create?name=teste&age=25

## 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')
, url = require('url')
, SUCCESS = {
    version: '1.0'
    , name: 'be MEAN'
    , returned_at: new Date().toJSON()
}
, ERROR = {
    message: "Rota não econtrada"
};

http.createServer(function(req, res){
    switch(req.url){

        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(400,{'Content-Type':'application;json;charset=utf-8'});
        res.write(JSON.stringify(ERROR));
        break;
    }

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


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

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

**autor:** Victor Igor Gomes Martins

**date:** 1453957583405

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

1. POST
2. GET
3. PUT
4. 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/).

*Status Codes* eles são códigos de retorno do nosso servidor, ele possui uma padronização para poder saber a informação que ele trás.

1º Exemplo: 100

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

2º Exemplo: 200

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

3º Exemplo: 301 Movido

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

4º Exemplo: 404

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

5º Exemplo: 500

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

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

Ela recebe uma função anônima com dois parâmetros:

1. request
2. response

`request`: recebe informação da solicitação feita ao servidor

`response`: a resposta dada requisição solicitada

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

QueryString é os valores que passamos por parâmetro na url, como por exemplo:

http://localhost:3000/name=1&idade=12

Como o próprio nome diz, é de uma certa forma uma query, onde serve para pegar seu
valor e trabalhar no código.

## 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   : 'Victor Igor'
        , returned_at: date
      }
      , ERRO = {
          message: 'Não encontrado !!!'
      }
    ;
http.createServer((request, response)=>{
    var routes = ['/api/pokemons/create', '/api/pokemons/read',
                  '/api/pokemons/update', '/api/pokemons/delete'
                 ];
  function successRes(){
    response.writeHead(200, {'Content-Type': 'application/json'});
    response.write(JSON.stringify(SUCCESS));
  }
  function erroRes(){
    response.writeHead(404, {'Content-Type':'application/json;charset=utf-8'});
    response.write(JSON.stringify(ERRO));
  }
  switch (request.url) {
    case routes[0]:
      successRes();
      break;
    case routes[1]:
      successRes();
      break;
    case routes[2]:
      successRes();
      break;
    case routes[3]:
      successRes();
      break;
    default:
      erroRes();

  }
  response.end();
}).listen(3000,()=>{
    console.log('Servidor rodando em http://localhost:3000');
});

```


text:
# NodeJS - Aula 02 - Exercício
autor: Fábio Calheiros (conta: fabiocalheiros)

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

```

- 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, servem para obtermos resposta de uma requisição.
100 - Informacional (https://http.cat/100)
200 - Sucesso(OK) (https://http.cat/200)
301 - Movido permanamentemente (https://http.cat/301)
404 - Não encontrado (https://http.cat/404)
503 - Serviço indisponível (https://http.cat/503)

```

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

```
// utilizando o protocolo http, cria-se um função anônima que recebe dois parâmetros
// req - requisição (Parametro enviado)
// res - nome da função de retorno
http.createServer(function(req, res){

    // veririca se a url informada é = '/api/v1'
    if(req.url === '/api/v1'){
        // retorna um cabeçalho de resposta OK no formato json
        res.writeHead(200, {'Content-Type': 'application/json'});
        // Escreve o retorno transformando a mensagem de SUCESSO em uma string
        res.write(JSON.stringify(SUCCESS))
    }else{
        // Caso não encontre a url, monta uma cabeçalho com o erro de página não encontrada
        res.writeHead(404, {'Content-Type': 'application/json; charset=utf-8'});
        // Escreve o retorno transformando a mensagem de ERRO em uma string
        res.write(JSON.stringify(ERROR))
    }
    // finaliza a resposta
    res.end();
// quando o server for iniciado com sucesso
}).listen(3000, function(){
    // escreve a mensagem que o servidor está rodando na porta 3000
    console.log('Servidor rodando em localhost:3000');
});

```

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

```
Querystring é uma leitura de url obtida através do método request.url que retorna uma string sobre o que foi digitado no endereço url do seu browser.
A querystring serve para obertermos os valores informados pelo usuário e fazer as rotas, ou inserir os valores de acordo com o que foi recebido.

```

# 5. 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(request, response){
    var result = request.url;
    var rotas = [ '/api/pokemons/create', '/api/pokemons/read', '/api/pokemons/update', '/api/pokemons/delete'];

    for(var key in rotas){
        if (rotas[key] === result) {
          response.writeHead(200, {'Content-Type': 'text/html; charset=utf-8'});
          response.write(JSON.stringify(SUCESS));
          response.end();
        }else{
          response.writeHead(404, {'Content-Type': 'text/html; charset=utf-8'});
          response.write(JSON.stringify(ERROR));
          response.end();
        }
    }

  response.end();

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

```


text:
# Node.js - Aula 02 - Exercício
**user:** [augustoody](https://github.com/AugustoOdy)
**autor:** Augusto Ody
**date:** 1454765252713

## 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/).

Os *Status codes* foram inventados para retornar ao cliente o que ocorreu com sua requisição.

# Class 1XX (Informação)

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

# Class 2XX (Sucesso)

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

# Class 3XX (Redirecionamento)

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

# Class 4XX (Erro de cliente)

![Class 4XX](https://http.cat/401)

# Class 5XX (Erro de servidor)

![Class 5XX](https://http.cat/508)

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

*Request:* Informações da requisição feita pelo cliente.
*Response:* Retorno das informações requeridas pelo `request`.

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

*Querystrings* são um conjunto dados, que utilizam chaves e valores anexados na URL. Sua utilização é principalmente para passagem de valores.

Sintaxe:

```
http://site.com/?arg1=value1&arg2=value2&arg3=value3
```

Sendo o primeiro informado após o simbolo `?`, e os seguintes com `&`.

## 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
      }
    , USERS = [
        { name: 'Docand Whitsandy' }
      , { name: 'Adas Footfair' }
      , { name: 'Cading Weed-fair' }
      , { name: 'Boli Hay-gardner' }
      , { name: 'Mismé Butcherward' }
      , { name: 'Diding Blowerbottom' }
      , { name: 'Latle Brace-man' }
      , { name: 'Agolbel Goodboffin' }
      , { name: 'Goever Butchergammidge' }
      , { name: 'Inggo Chubb-brace' }
    ]
    , PHOTOS = [
        { path: '/image/1.jpg' }
      , { path: '/image/2.jpg' }
      , { path: '/image/3.jpg' }
    ]
    , ERROR = {
        message: "Não encontrado!"
      }
    ;

http.createServer(function(req, res){
  switch (req.url) {
    case '/api/v1':
      res.writeHead(200, {'Content-Type': 'application/json'});
      res.write(JSON.stringify(SUCCESS));
      break;
    case '/api/v1/users':
      res.writeHead(200, {'Content-Type': 'application/json'});
      res.write(JSON.stringify(USERS));
      break;
    case '/api/v1/photos':
      res.writeHead(200, {'Content-Type': 'application/json'});
      res.write(JSON.stringify(PHOTOS));
      break;
    case '/api/v1/single':
      res.writeHead(200, {'Content-Type': 'application/json'});
      res.write(JSON.stringify({USERS}));
      break;
    default:
      res.writeHead(404, {'Content-Type': 'application/json'});
      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:** Ednilson Amaral
**Data:** 1450649579988

## 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.

Toda vez que é enviada uma requisição para o servidor, é enviada como resultado um código de número inteiro, contendo 3 dígitos. Isso, com o intuito de entender a requisição e realizar ou não a requisição. Esse código de 3 dígitos é chamado de **status code**.

Esses códigos são divididos em grupos. Tais grupos são divididos pelo primeiro dígito do código, conforme os exemplos abaixo:

### 1xx Informações

Esse grupo serve apenas para informar que a informação foi recebida e que o processo irá continuar.

![100 - Continue](https://raw.githubusercontent.com/ednilsonamaral/be-mean-instagram-nodejs/master/img/100.jpg)

### 2xx Sucesso

Esse grupo significa que a requisição foi recebida com sucesso.

![202 - Accepted](https://raw.githubusercontent.com/ednilsonamaral/be-mean-instagram-nodejs/master/img/202.jpg)

### 3xx Redirecionamento

Esse grupo serve para avisar diretamente no cabeçalho do HTTP uma mudança de página.

![301 - Moved Permanently](https://raw.githubusercontent.com/ednilsonamaral/be-mean-instagram-nodejs/master/img/301.jpg)

### 4xx Erro do Cliente

Esse grupo serve para nos dizer que o conteúdo não está acessível para o usuário (visitante) e nem para os motores de busca.

![400 - Bad Request](https://raw.githubusercontent.com/ednilsonamaral/be-mean-instagram-nodejs/master/img/400.jpg)

### 5xx Erro de Servidor

Esse grupo serve para mostrar que alguma coisa aconteceu para que o servidor não tenha atendido a requisição, devido à algum erro.

![507 - Insufficient Storage](https://raw.githubusercontent.com/ednilsonamaral/be-mean-instagram-nodejs/master/img/507.jpg)

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

```js
var http = require('http');

http.createServer(function(request, response){
  response.writeHead(200, {"Content-Type": "text/plain"});
  response.write("Be MEAN");
  response.end();
}).listen(3000, function(){
  console.log('Servidor rodando em localhost:3000');
});
```

* Request: possui a requisição do usuário para o servidor;
* Response: é quando o servidor irá dar a resposta da requisição do usuário.

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

`index.html?nome=Ednilson&idade=23`

No link acima, vemos a variável `nome=Ednilson` e a variável `idade=23`, logo após o `?`. Essas variáveis e valores são *querystring*. Elas são enviadas via **URL**. São enviadas através de formulários via `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();

var http = require('http')
  , url = require('url')
  , SUCCCESS =
    { version: '1.0'
    , name: 'JSON para 4 rotas diferentes'
    , returned_at: date
    }
    , ERROR = {
        message: "Deu alguma merda, mano!"
    }
  ;

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(SUCCESS));
    } else {
      response.writeHead(404, {'Content-Type': 'application/json; charset=UTF-8'});
      response.write(JSON.stringfy(ERROR));
    }
  }

  response.end();

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


text:
# Node.js - Aula 02 - Exercício
# autor: Sergio Kopplin
# data: 1454721080991

## 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).

Os Status Codes são códigos de retorno e foram críados para formar um padrão de direcionamento para a identificação correta de retorno das requisições HTTP.

* Grupo Informação.
	- 100 (continue):O Cliente DEVE continuar com a requisição pois ela foi recebida pelo servidor e o mesmo não a rejeitou. (https://http.cat/100).

* Grupo Sucesso.
	- 202 (accepted): A requisição foi sucedida e a informação retornada dependerá do tipo de método utilizado na requisição. (https://http.cat/202).

* Grupo Redirecionamento.
	- 301 (moved permanently): A fonte do recurso está em uma diferente URI e as referências futuras deverão utilizar umas das URIS retornadas. (https://http.cat/301).

* Grupo Erro do cliente.
	- 400 (bad request): A requisição não pode ser entendida pelo servidor devido a um problema de syntax. O Cliente não deverá repetir a requisição sem antes modificá-la.. (https://http.cat/400).

* Grupo Erro do servidor.
	- 500 (internal server erros): O servidor encontrou um problema inesperado e isso o impediu de responder a requisição. (https://http.cat/500).

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

A função **createServer** é uma função anônima que é executada automaticamente e que recebe 2 parâmetros, request e response.
No request nós temos as informações da requisição por parte do cliente e no response nós temos as informações da requisição por parte do servidor.

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

A QueryString é um modelo do qual nós passamos valores para o servidor pela url.
Ex: http://example.com/over/there?name=ferret.

Nesse exemplo, passamos a variável name com o valor ferret.

ref: [en.wikipedia.org](https://en.wikipedia.org/wiki/Query_string)

## 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'
        , created_at: date }
    , ERROR = {
        message: 'Não encontrado'
    };

http.createServer(function(req, res){
    switch (req.url) {
        case "/api/v1/pokemons/create":
            res.writeHead(200, {'Content-type': 'application/json; charset=utf-8'});
            res.write(JSON.stringify(SUCCESS));
            break;

        case "/api/v1/pokemons/read":
            res.writeHead(200, {'Content-type': 'application/json; charset=utf-8'});
            res.write(JSON.stringify(SUCCESS));
        break;

        case "/api/v1/pokemons/update":
            res.writeHead(200, {'Content-type': 'application/json; charset=utf-8'});
            res.write(JSON.stringify(SUCCESS));
            break;

        case "/api/v1/pokemons/delete":
            res.writeHead(200, {'Content-type': 'application/json; charset=utf-8'});
            res.write(JSON.stringify(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:
# Node.js - Aula 02 - Exercício
**user:** [lucasduarte](https://github.com/lucasduarte)
**autor:** Lucas Duarte Anício

## 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/).

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

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

####**3XX:** Redirecionamento
![307](https://http.cat/307)

####**4XX:** Erro do Cliente
![415](https://http.cat/415)

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

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

- **Request:**
Contem dados da requisição recebida do cliente
- **Response:**
Possui dados para responder a requisição efetuada pelo cliente

## O que é e para que serve a Querystring?
É um conjunto de chave/valor que serve para recuperar dados nas páginas

## 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()
    , rotas = [ 'create', 'read', 'update', 'delete' ];

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 method = req.url.replace('/api/pokemons/', '');

	if(req.url === '/api/pokemons/' + method && rotas.indexOf(method) > -1) {
		res.writeHead(200, {'Content-Type': 'application/json'});
        SUCCESS.metodo = method;
		res.write(JSON.stringify(SUCCESS));
	}
	else {
		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:
#NodeJS - Aula 02 - Exercícios
autor: Dariano Soares

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

- **Create   	- POST**
- **Retrieve 	- GET**
- **Update 	- PUT**
- **Delete 	- DELETE**

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

O **Status Code** é uma representação numérica da resposta. Um inteiro de três dígitos que informa o stado do retorno.

**1xx** - Indica uma resposta provisória.
Ex: **100 Continuar** significa que o servidor recebeu os cabeçalhos da solicitação.

**2xx** - Indica que a requisição foi recebida, entendida e aceita.
Ex: **201 Criado**  para quando algo for criado.

**3xx** - Indica que futuras ações precisam ser feitas para que a requisição seja completada.
Ex: **301 Movido** para redirecionamentos permanentes, quando algum recurso for movido de lugar por tempo indeterminado ou para sempre.

**4xx** - Indica algum erro do cliente.
Ex: **403 Proibido**   para indicar uma ação proibida.

**5xx** - Indica algum erro no servidor.
Ex: **500** erro genérico interno no servidor.

Referência -> Livro Construindo Aplicações com NodeJS, William Bruno Moraes
##3. Explique o que é cada parâmetro da função recebida no `createServer`.

Os dois parâmetros da função **createServer** são os objetos **request** e **response**, que representam uma requisição HTTP, que consiste sempre em um pedido e uma resposta respectivamente.

Referência -> Livro Construindo Aplicações com NodeJS, William Bruno Moraes
##4. O que é e para que serve a `Querystring`?

**Querystring** é o padrão que o protocolo HTTP utiliza para transporte de informações do cliente para o servidor.
Devemos utilizar a query para filtrar dados. A sintaxe de uma query string é <busca>=<valor>. Indicamos que vamos concatenar mais uma busca após outra com o caracter &(e comercial). O início da query string é indicado pelo caractere ? (interrogação).
```
ex: ?<query>=<value>&<query2>=<value2>&<query3>=<value3>
```
Referência -> Livro Construindo Aplicações com NodeJS, William Bruno Moraes
##5. Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
```js

'use strict';

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

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

let server = 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();
});

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

```


text:
# Node.js - Aula 02 - Exercício
**user:** [carloshenriqueribeiro](https://github.com/carloshenriqueribeiro)
**autor:** Carlos Henrique Oliveira Ribeiro
**date:** 1501525417786

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

CRUD | Descrição | Verbo |
-----|-----------|-------|
C|Create|POST
R|Read|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 client e server, 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 .

##### 404 - Não Encontrado
![Não encontrado](https://http.cat/404)
Conhecido na internet o **status code** 404 é de "page not found" ou "página não encontrada".

##### 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 ou req` e `response ou res`.

`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 client e server. 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=carlos&idade=29

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
//server.js

'use strict';

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

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

http.createServer(function(request, response) {

  switch (request.url) {

    case '/api/pokemons/create':
      response.writeHead(200, {'Content-type': 'application/json; charset=utf-8'});
      SUCCESS.url = request.url;
      response.write(JSON.stringify(SUCCESS));
      break;

    case '/api/pokemons/read':
      response.writeHead(200, {'Content-type': 'application/json; charset=utf-8'});
      SUCCESS.url = request.url;
      response.write(JSON.stringify(SUCCESS));
      break;

    case '/api/pokemons/update':
      response.writeHead(200, {'Content-type': 'application/json; charset=utf-8'});
      SUCCESS.url = request.url;
      response.write(JSON.stringify(SUCCESS));
      break;

    case '/api/pokemons/delete':
      response.writeHead(200, {'Content-type': 'application/json; charset=utf-8'});
      SUCCESS.url = request.url;
      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:** [carlosmachel](https://github.com/carlosmachel)
**autor:** Carlos Machel
**date:** 1458182711164

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

**Create** : verbo POST

**Retrieve/Read** : verbo GET

**Update** : verbo PUT

**Delete** : verbo 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 code` foram criados para ser uma forma padronizada do servidor retornar informações para o cliente que fez uma requisição. Lembrando que a má utilização dos status code pode gerar impacto no SEO da página.

### 101 - Continue

Criado para indicar que o client pode mandar a requisição completa. Funciona semelhante a um `handshake`, o client envia para uma primeira requisição perguntando se o servidor vai aceitar. Se o retorno for 101 é para enviar a requisição completa.

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

### 200 OK

A requisição foi um sucesso.

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

### 301 - Moved Permanently

O servidor retornou indicando que aquele recurso foi movido permanentemente para uma outra URI.

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

### 408 Request Timeout

O client não produziu um request no tempo que o servidor estava preparado para esperar.

![img](https://http.cat/408)

### 503 Service Unavailable

O servidor não pode lidar com o request devido a uma manutenção ou sobrecarga temporaria.

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

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

Essa função contém dois parâmetros.

- `request`
Que nada mais é do que um objeto que contém todas as informações relacionadas ao request do client para aquele servidor. Ele vai conter IP, HTTP headers, url e parametros.
Ele é uma instância da classe [http.IncomingMessage](https://nodejs.org/api/http.html#http_class_http_incomingmessage)

- `response`
Que é o resultado que o servidor retorna para o client. Pode ser uma string, um objeto, uma página html.
É uma instância de [http.ServerResponse](https://nodejs.org/api/http.html#http_class_http_serverresponse)

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

Uma querystring é uma sequencia de caracteres com uma estrutura `chave` e `valor`, adicionados na URL de requisição ao servidor contendo informações. A recomendação é que se use para `filtro` de contéudo e não para indicar recursos.

### Mau uso de querystring

> /api?type=user&id=23

### Bom uso de queryString

> /product?price=3.15&compare=lowerthan

## 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')
,   url    = require('url')
,   ERROR = {
        message: 'Não encontrado'
    }
;

var SUCCESS = {
        version: 1.0
    ,   name:'Be MEAN'
    ,   returned_at: date
};

const routes = [
      { path: '/api/pokemons/create', name: 'create' }
    , { path: '/api/pokemons/read', name: 'read' }
    , { path: '/api/pokemons/update', name: 'update' }
    , { path: '/api/pokemons/delete', name: 'delete' }
]

http.createServer(function(req, res){
    const pathName = url.parse(req.url).pathname;
    var route = routes.find(route => route.path == pathName);

    if(route){
        SUCCESS.name = route.name;
        res.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
        res.write(JSON.stringify(SUCCESS));
    } else{
        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:** [MalvesGO](https://github.com/MalvesGO)

**Autor:** Marcelo Alves

**Date:** Dom Dez 13 17:27:57 BRST 2015

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

# Create: POST
# Retrieve: 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/).

Status Codes foram criados para ter um padrão especifico de erros retornados pelo servidor. Estes códigos nos permitem identificar a causa do problema quando utilizamos uma página web e o recurso não é carregado corretamente.

* **1XX** - Continue

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

* **2XX** - Accepted

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

* **3XX** - Unauthorized

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

* **4XX** - Blocked by Windows Parental Controls

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

* **5XX** - Network connect timeout error

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

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

#Request

Possui todos os parâmetros utilizados na requisição de dados solicitada pelo usuário.

#Response

Possui todos os métodos utilizados para o envio de respostas para o usuário.

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

É um padrão utilizado no protocolo HTTP que permite o envio de informações através de requisições ao servidor. Podemos observar o seu uso em vários navegadores no seguinte formato pares/valores anexados a URL visitada. Para podermos utilizar precisamos adicionar o valor da seguinte forma: "?Key=value" exemplificando melhor: "?title=nodejs". Se for necessário utilizar mais de um conjunto de chaves/valores precisaremos concatenar usando o caractere especial "&" coringa.

Exemplo: www.malvesgo.github.io?name=Marcelo&ocupation=student

## 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:** [fauker](https://github.com/fauker)

**autor:** LUCAS DA SILVA MOREIRA

## Quais são os 4 verbos que utilizamos para o CRUD?
`GET`, `POST`, `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/).
Para padronizar o retorno do servidor.

1xx - Informational

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

2xx - Successful

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

3xx - Redirection

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

4xx - Client Error

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

5xx - Internal Server Error

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

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

`createServer(function(request, response){});`

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

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

Principais propriedades de cada um deles:

**Request:**

- Corpo do HTTP response;
- Número de Bytes enviados pelo cliente;
- Coleção de cabeçalhos;
- Porta servidor utilizada;
- Estado do servidor;
- Nome do servidor;
- Verificação de conexão SSL.

**Response:**

- Corpo do request HTTP;
- Código da página para o corpo Request;
- Versão do HTTP;
- Caminho do HTTP;
- Tamanho do Buffer;

## O que é e para que serve a Querystring?
São nada mais do que conjuntos de pares/valores anexados a URL.

Serve para alterarmos o estado de uma página web.

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:

```
// server.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/v1/pokemons/create':
      response.writeHead(200, {'Content-Type': 'application/json'});
      response.write(JSON.stringify(SUCCESS));
      break;
    case '/api/v1/pokemons/read':
      response.writeHead(200, {'Content-Type': 'application/json'});
      response.write(JSON.stringify(SUCCESS));
      break;
    case '/api/v1/pokemons/update':
      response.writeHead(200, {'Content-Type': 'application/json'});
      response.write(JSON.stringify(SUCCESS));
      break;
    case '/api/v1/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('Servidor rodando em localhost:3000');
});

```