text
stringlengths 2
104M
| meta
dict |
|---|---|
# 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
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
O servidor processou a solicitação com sucesso, mas não é necessário nenhuma resposta.
##### 301 - Movido permanentemente
Esta e todas as solicitações futuras devem ser direcionada para o URI .
##### 404 - Não Encontrado
Conhecido na internet o **status code** 404 é de "page not found" ou "página não encontrada".
##### 500 - Erro interno no servidor
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');
});
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# 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.
### 200 OK
A requisição foi um sucesso.
### 301 - Moved Permanently
O servidor retornou indicando que aquele recurso foi movido permanentemente para uma outra URI.
### 408 Request Timeout
O client não produziu um request no tempo que o servidor estava preparado para esperar.
### 503 Service Unavailable
O servidor não pode lidar com o request devido a uma manutenção ou sobrecarga temporaria.
## 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');
});
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# 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
* **2XX** - Accepted
* **3XX** - Unauthorized
* **4XX** - Blocked by Windows Parental Controls
* **5XX** - Network connect timeout error
## 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');
});
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# 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
2xx - Successful
3xx - Redirection
4xx - Client Error
5xx - Internal Server Error
## 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');
});
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 08 - Exercício
**user:** [ednilsonamaral](https://github.com/ednilsonamaral)
**autor:** Ednilson Amaral
## 1 - Insira 5 pokemons novos, na coleção `pokemons`, escolha 3 e os adicione em um array e uma nova coleção chamada `meus-pokemons`, utilizando o `ObjectId`. Adicione o `required` em campos que ache obrigatório no *Schema* do Pokemon.
### Inserindo 5 pokemons novos
`crud.js`
```js
'use strict';
const mongoose = require('mongoose');
const dbURI = 'mongodb://localhost/be-mean-pokemons';
mongoose.connect(dbURI);
const Schema = mongoose.Schema;
const _schema = {
name: {type: String, required: true, match: /^./i},
description: {type: String, required: true, match: /^./i},
type: {type: String, required: true, match: /^./i},
attack: {type: Number, min: 1},
height: {type: Number}
};
const PokemonSchema = new Schema(_schema);
const PokemonModel = mongoose.model('pokemons', PokemonSchema);
//inserindo os 5 novos pokemons
const data = [
{
name: 'Educamon',
description: 'O pokemon mais educadinho do universo',
type: 'educador',
attack: 76,
height: 1.7
},
{
name: 'NFLMon',
description: 'O pokemon mais QB, fanático por NFL, qualquer um que se aproxime ele dá um tackle',
type: 'player',
attack: 105,
height: 2.3
},
{
name: 'JiuJiteroMon',
description: 'Faixa preta 3º grau',
type: 'jiujitsu',
attack: 153,
height: 1.6
},
{
name: 'BaianoMon',
description: 'O pokemon mais preguiçoso do universo',
type: 'preguiça',
attack: 51,
height: 1.7
},
{
name: 'GoogleMon',
description: 'O pokemon mais googlet do universo',
type: 'google',
attack: 99,
height: 1.7
},
];
PokemonModel.create(data, (err, data) => {
if (err) return console.log('Erro: ', err);
console.log('Inserido(s): ', data);
});
```
Saída no terminal:
```
$ node app.js
Mongoose default connection error: Error: Trying to open unclosed connection.
Mongoose default connection connected to mongodb://localhost/be-mean-pokemons
Mongoose default connection is open
Inserido(s): [ { _id: 56d841324d9d0e4b13764e93,
height: 1.7,
attack: 76,
type: 'educador',
description: 'O pokemon mais educadinho do universo',
name: 'Educamon',
__v: 0 },
{ _id: 56d841324d9d0e4b13764e94,
height: 2.3,
attack: 105,
type: 'player',
description: 'O pokemon mais QB, fanático por NFL, qualquer um que se aproxime ele dá um tackle',
name: 'NFLMon',
__v: 0 },
{ _id: 56d841324d9d0e4b13764e95,
height: 1.6,
attack: 153,
type: 'jiujitsu',
description: 'Faixa preta 3º grau',
name: 'JiuJiteroMon',
__v: 0 },
{ _id: 56d841324d9d0e4b13764e96,
height: 1.7,
attack: 51,
type: 'preguiça',
description: 'O pokemon mais preguiçoso do universo',
name: 'BaianoMon',
__v: 0 },
{ _id: 56d841324d9d0e4b13764e97,
height: 1.7,
attack: 99,
type: 'google',
description: 'O pokemon mais googlet do universo',
name: 'GoogleMon',
__v: 0 } ]
```
### Escolhendo 3 pokemons e inserindo em uma nova coleção com o `ObjectId`.
`ref.js`
```js
'use strict';
const mongoose = require('mongoose');
const dbURI = 'mongodb://localhost/be-mean-pokemons';
mongoose.connect(dbURI);
const Schema = mongoose.Schema;
const _schema = {
pokemons: [{type: Schema.Types.ObjectId, ref: 'pokemons'}]
};
const PokemonSchema = new Schema(_schema);
const PokemonModel = mongoose.model('meus-pokemons', PokemonSchema);
//inserindo os 3 pokemons escolhidos com ObjectID
const data = {
pokemons: ['56d841324d9d0e4b13764e97', '56d841324d9d0e4b13764e96', '56d841324d9d0e4b13764e95']
};
PokemonModel.create(data, (err, data) => {
if (err) return console.log('Erro: ', err);
console.log('Inserido(s): ', data);
});
```
Saída no terminal:
```
$ node app.js
Mongoose default connection error: Error: Trying to open unclosed connection.
Mongoose default connection connected to mongodb://localhost/be-mean-pokemons
Mongoose default connection is open
Inserido(s): { pokemons:
[ 56d841324d9d0e4b13764e97,
56d841324d9d0e4b13764e96,
56d841324d9d0e4b13764e95 ],
_id: 56d843ae813254aa1312e7a7,
__v: 0 }
```
## 2 - Crie um *Schema* de exemplo com validação para os campos (utilizar Arquitetura Atômica, ou seja cada campo sendo um Schema separado):
* email;
* cpf;
* cnpj;
* url;
* ip.
`app.js`
```js
'use strict';
require('./db/config');
const CRUD = require('./controller');
const data = {
email: 'ednilsonamaral.ti@gmail.com',
cpf: 12345678,
cnpj: 123654,
url: 'www.ednilsonamaral.com.br',
ip: '192.168.0.1'
};
CRUD.create(data);
```
`schema.js`
```js
const mongoose = require('mongoose');
const Schema = mongoose.Schema;
const email = require('./fields/field-email');
const cpf = require('./fields/field-cpf');
const cnpj = require('./fields/field-cnpj');
const url = require('./fields/field-url');
const ip = require('./fields/field-ip');
const _schema = {
email,
cpf,
cnpj,
url,
ip
};
module.exports = new Schema(_schema);
```
`model.js`
```js
module.exports = function (Schema, ModelName) {
const mongoose = require('mongoose');
return mongoose.model(ModelName, Schema);
};
```
`controller.js`
```js
'use strict';
const Schema = require('./schema');
const Model = require('./model')(Schema, 'atomicos');
const CRUD = {
create: function(data) {
console.log("create: ", data);
const AmoticosModel = new Model(data);
AmoticosModel.save(function (err, data) {
if (err) return console.log('ERRO: ', err);
return console.log('Inseriu:', data);
});
},
retrieve: function(query) {
Model.find(query, function (err, data) {
if (err) return console.log('ERRO: ', err);
return console.log('Buscou:', data);
});
},
update: function(query, mod, options) {
var options = options || {};
Model.update(query, mod, options, function (err, data) {
if (err) return console.log('ERRO: ', err);
return console.log('Alterou:', data);
});
},
delete: function(query) {
Model.remove(query, function (err, data) {
if (err) return console.log('ERRO: ', err);
return console.log('Deletou:', data);
});
},
};
module.exports = CRUD;
```
`fields`
```js
//field-email.js
module.exports = {
type: String,
match:
[
/^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/,
'Preencha um e-mail válido!'
],
required: true
}
//field-cpf.js
module.exports = {type: Number, minlength: 3, maxlength: 11, required: true}
//field-cnpj.js
module.exports = {type: Number, minlength: 3}
//field-url.js
module.exports = {type: String, required: true, match: /([\w-]+\.)+[\w-]+(\/[\w- .\/?%&=]*)?/}
//field-ip.js
module.exports = {type: String, maxlenght: 15}
```
Saída no terminal:
```
$ node app.js
create: { email: 'ednilsonamaral.ti@gmail.com',
cpf: 12345678,
cnpj: 123654,
url: 'www.ednilsonamaral.com.br',
ip: '192.168.0.1' }
Mongoose default connection connected to mongodb://localhost/bancoTeste
Mongoose default connection is open
Inseriu: { _id: 56d84cfdac4d9e351638cce0,
ip: '192.168.0.1',
url: 'www.ednilsonamaral.com.br',
cnpj: 123654,
cpf: 12345678,
email: 'ednilsonamaral.ti@gmail.com',
__v: 0 }
```
## 3 - Dê 3 exemplos **diferentes**, de cada, utilizando as funções:
### Schema e Model
```js
'use strict';
const mongoose = require('mongoose');
const dbURI = 'mongodb://localhost/be-mean-pokemons';
mongoose.connect(dbURI);
const Schema = mongoose.Schema;
const _schema = {
name: {type: String, required: true, match: /^./i},
description: {type: String, required: true, match: /^./i},
type: {type: String, required: true, match: /^./i},
attack: {type: Number, min: 1},
height: {type: Number}
};
const PokemonSchema = new Schema(_schema);
const Model = mongoose.model('pokemons', PokemonSchema);
```
### `findAndModify`
`findAndModify.js`
```js
'use strict';
const mongoose = require('mongoose');
const dbURI = 'mongodb://localhost/be-mean-pokemons';
mongoose.connect(dbURI);
const Schema = mongoose.Schema;
const _schema = {
name: {type: String, match: /^./i},
description: {type: String, match: /^./i},
type: {type: String, match: /^./i},
attack: {type: Number, min: 1},
height: {type: Number}
};
const PokemonSchema = new Schema(_schema);
PokemonSchema.statics.findAndModify = function (query, sort, doc, options, callback) {
return this.collection.findAndModify(query, sort, doc, options, callback);
};
const Model = mongoose.model('pokemons', PokemonSchema);
const query = {attack: {$lte: 51}};
const mod = {type: 'new york giants'};
const opt = {multi: true};
Model.findAndModify(query, [], mod, opt, function (err, data) {
if (err) return console.log('Erro: ', err);
return console.log('Alterou: ', data);
});
```
Saída no terminal:
```
$ node findAndModify.js
Alterou: { lastErrorObject: { updatedExisting: true, n: 1 },
value:
{ _id: 56aeb9d04bb106b114749436,
name: 'Nerdmon',
description: 'Deu um upgrade, pode melhorar, parça!',
type: 'nerd',
attack: 51,
defense: 888,
height: 1.8,
__v: 0 },
ok: 1 }
```
Na documentação do Mongoose diz que não possui o `findAndModify`, então, com a ajuda de alguns colegas e pesquisando na net, foi mencionado uma alternativa, utilizando o `.statics`, conforme exemplo acima.
###`findOneAndUpdate`
#### Exemplo 1
`findOneAndUpdate.js`
```js
const query = {name: /nflmon/i};
const mod = {type: 'professional'};
const options = {};
Model.findOneAndUpdate(query, mod, options, function (err, data) {
if (err) return console.log('Erro: ', err);
return console.log('Alterou: ', data);
})
```
Saída no terminal:
```
$ node findOneAndUpdate.js
Alterou: { __v: 0,
height: 2.3,
attack: 105,
type: 'player',
description: 'O pokemon mais QB, fanático por NFL, qualquer um que se aproxime ele dá um tackle',
name: 'NFLMon',
_id: 56d841324d9d0e4b13764e94 }
```
#### Exemplo 2
`findOneAndUpdate.js`
```js
const query = {attack: {$lte: 50}};
const mod = {attack: 999};
const options = {multi: true};
Model.findOneAndUpdate(query, mod, options, function (err, data) {
if (err) return console.log('Erro: ', err);
return console.log('Alterou: ', data);
});
```
Saída no terminal:
```
$ node findOneAndUpdate.js
Alterou: { moves: [ 'engole fogo', 'assopra veneno', 'desvio' ],
active: false,
height: 0.4,
attack: 49,
type: 'grama',
description: 'Chicote de trepadeira',
name: 'Bulbassauro',
_id: 564cff04f9025dedb2553204 }
```
#### Exemplo 3
`findOneAndUpdate.js`
```js
const query = {$and: [{type: 'nerd'}, {attack: {$gte: 40}}]};
const mod = {attack: 51, description: 'Deu um upgrade, pode melhorar, parça!'};
const options = {multi: true};
Model.findOneAndUpdate(query, mod, options, function (err, data) {
if (err) return console.log('Erro: ', err);
return console.log('Alterou: ', data);
});
```
Saída no terminal:
```
$ node findOneAndUpdate.js
Alterou: { __v: 0,
height: 1.8,
defense: 888,
attack: 49,
type: 'nerd',
description: 'O pokemon mais nerd que já existiu, que existe ou que existirá',
name: 'Nerdmon',
_id: 56aeb9d04bb106b114749436 }
```
###`findOneAndRemove`
#### Exemplo 1
`findOneAndRemove.js`
```js
const query = {attack: null};
Model.findOneAndRemove(query, function (err, data) {
if (err) return console.log('Erro: ', err);
return console.log('Removeu: ', data);
});
```
Saída no terminal:
```
$ node findOneAndRemove.js
Removeu: { description: 'Sem maiores informações',
moves: [],
defense: null,
height: null,
attack: null,
name: 'AindaNaoExisteMom',
_id: 564de099fc7e5880d64a877e }
```
#### Exemplo 2
`findOneAndRemove.js`
```js
const query = {$and: [{type: 'google'}, {height: {$gte: 1.5}}]};
Model.findOneAndRemove(query, function (err, data) {
if (err) return console.log('Erro: ', err);
return console.log('Removeu: ', data);
});
```
Saída no terminal:
```
$ node findOneAndRemove.js
Removeu: { __v: 0,
height: 1.7,
attack: 99,
type: 'google',
description: 'O pokemon mais googlet do universo',
name: 'GoogleMon',
_id: 56d841324d9d0e4b13764e97 }
```
#### Exemplo 3
`findOneAndRemove.js`
```js
const query = {height: {$lte: 1.7}};
Model.findOneAndRemove(query, function (err, data) {
if (err) return console.log('Erro: ', err);
return console.log('Removeu: ', data);
});
```
Saída no terminal:
```
$ node findOneAndRemove.js
Removeu: { moves: [ 'engole fogo', 'assopra veneno', 'desvio' ],
active: false,
height: 0.4,
attack: 999,
type: 'grama',
description: 'Chicote de trepadeira',
name: 'Bulbassauro',
_id: 564cff04f9025dedb2553204 }
```
## 4 - Crie 1 *Schema* com todo CRUD funcional e métodos especiais, que agrupe:
* virtuals;
* getters & setters;
* method & static;
* embedded document;
* plugins;
* middlewares.
Realizei a importação do `fighters.json` no *database* para trabalhar com o CRUD em cima de alguns documentos já presentes, e, também adicionei um novo documento via `app.js`.
`fighters.json`
```js
{name: {first: 'Demetrious', last: 'Johnson'}, age: 29, weight_class: 'Flyweight'}
{name: {first: 'Joseph', last: 'Benavidez'}, age: 31, weight_class: 'Flyweight'}
{name: {first: 'Conor', last: 'McGregor'}, age: 27, weight_class: 'Featherweight'}
{name: {first: 'José', last: 'Aldo'}, age: 29, weight_class: 'Featherweight'}
{name: {first: 'Domminick', last: 'Cruz'}, age: 30, weight_class: 'Bantamweight'}
```
Importando:
```
$ mongoimport --db bancoTeste --collection fighters --drop --file fighters.json
2016-03-07T14:13:25.769-0300 connected to: localhost
2016-03-07T14:13:25.770-0300 dropping: bancoTeste.fighters
2016-03-07T14:13:26.206-0300 imported 5 documents
```
Abaixo, os arquivos do CRUD funcional com os métodos solicitados.
`config.js`
```js
const mongoose = require('mongoose');
const dbURI = 'mongodb://localhost/bancoTeste';
mongoose.connect(dbURI);
mongoose.connection.on('connected', function () {
console.log('Mongoose default connection connected to ' + dbURI);
});
mongoose.connection.on('error',function (err) {
console.log('Mongoose default connection error: ' + err);
});
mongoose.connection.on('disconnected', function () {
console.log('Mongoose default connection disconnected');
});
mongoose.connection.on('open', function () {
console.log('Mongoose default connection is open');
});
process.on('SIGINT', function() {
mongoose.connection.close(function () {
console.log('Mongoose default connection disconnected through app termination');
process.exit(0);
});
});
```
`app.js`
```js
'use strict';
require('./db/config');
const CRUD = require('./controller');
//inserindo novo documento
const hab1 = {
title: 'Jiu Jitsu',
since: 2005
};
const hab2 = {
title: 'Muay Thai',
since: 1999
};
const hab3 = {
title: 'Boxe',
since: 2001
};
const data = {
name: {
first: 'Anderson',
last: 'Silva'
},
age: 42,
skills: [hab1, hab2, hab3],
weight_class: 'Middleweight'
};
CRUD.create(data);
//pesquisando um documento
const query = "56ddce078b09ec822118e4c7";
CRUD.retrieve(query);
//pesquisando através de um method
const query = {name: {first: 'Mauro', last: 'Filho'}, weight_class: /featherweight/i};
CRUD.retrieve_method(query);
//pesquisando através de uma static
const query = {name: {first: 'Anderson', last: 'Silva'}};
CRUD.retrieve_static(query);
//pesquisando através de middleware pre count
const query = {age: 29};
CRUD.retrieve_middleware(query);
```
`controller.js`
```js
'use strict';
const mongoose = require('mongoose');
const Schema = require('./schema');
const Model = require('./model')(Schema, 'fighters');
const CRUD = {
create: function(data) {
console.log("create: ", data);
const FighterModel = new Model(data);
FighterModel.save(function (err, data) {
if (err) return console.log('ERRO: ', err);
return console.log('Inseriu:', data);
});
},
retrieve: function(query) {
Schema
.virtual('name.full')
.get(function (){
return this.name.first + ' ' + this.name.last;
});
Model.findById(query, function (err, data) {
if (err) return console.log('ERRO: ', err);
return console.log('Nome: ', data.name.full, '\nCategoria de Peso: ', data.weight_class, '\nIdade: ', data.age);
});
},
retrieve_method: function(query){
Schema.methods.findSimilarType = function findSimilarType (callback) {
return this.model('MesmaCategoria', Schema);
};
const MethodModel = mongoose.model('MethodModel', Schema);
const outroFighter = new MethodModel(query);
outroFighter.findSimilarType(function (err, data){
if (err) return console.log('ERRO: ', err);
return data.forEach((fighters) => console.log('fighter: ', fighters));
});
},
retrieve_static: function(query) {
Schema.statics.search = function (name, callback) {
return this.where('name', new RegExp(name, 'i')).exec(callback);
};
const StaticModel = mongoose.model('StaticModel', Schema);
const maisOutro = new StaticModel(query);
maisOutro.search(query, function (err, data) {
if (err) return console.log('ERRO: ', err);
return data.forEach((fighters) => console.log('fighter: ', fighters));
});
},
retrieve_middleware: function(query){
const countQuery = Model.where(query).count((err, count) => {
if (err) return console.log('ERRO: ', err);
return console.log('Existem ' + count + ' lutadores com a mesma idade!');
});
},
update: function(query, mod, options) {
var options = options || {};
Model.update(query, mod, options, function (err, data) {
if (err) return console.log('ERRO: ', err);
return console.log('Alterou:', data);
});
},
delete: function(query) {
Model.remove(query, function (err, data) {
if (err) return console.log('ERRO: ', err);
return console.log('Deletou:', data);
});
},
};
module.exports = CRUD;
```
`model.js`
```js
module.exports = function (Schema, ModelName) {
const mongoose = require('mongoose');
return mongoose.model(ModelName, Schema);
};
```
`schema.js`
```js
const mongoose = require('mongoose');
const Schema = mongoose.Schema;
const name = require('./fields/field-name');
const age = require('./fields/field-age');
const weight_class = require('./fields/field-weight_class');
const created_at = require('./fields/field-created_at');
const skill = new Schema({
title: String,
since: Number
});
const _schema = {
name,
age,
weight_class,
skills: [skill],
created_at
};
module.exports = new Schema(_schema);
```
Aqui estão os *fields*:
```js
//field-name.js
module.exports = {
first: {type: String, match: /^./i},
last: {type: String, match: /^./i}
},{
toObject: {virtuals: true},
toJSON: {virtuals: true}
}
//field-age.js
module.exports = {type: Number, min: 18}
//field-skill.js
module.exports = {type: [skill]}
//field-weight_class.js
function toUpper (v) {
return v.toUpperCase();
}
module.exports = {
type: String,
match: /^./i,
get: toUpper
}
//field-created_at.js
module.exports = { type: Date, default: Date.now }
```
## 5 - Crie 1 *Schema* para `password` com criptografia e arquitetura atômica.
* use SHA256 com SALT como criptografia;
* use middleware com pre save;
* use methods.
`app.js`
```js
'use strict';
require('./db/config');
const CRUD = require('./controller');
const Model = require('./model');
const data = {
name: {
first: 'Ednilson',
last: 'Amaral'
},
password: '123456987'
}
CRUD.create(data);
```
`controller.js`
```js
'use strict';
const mongoose = require('mongoose');
const Schema = require('./schema');
const Model = require('./model')(Schema, 'userPass');
const CRUD = {
create: function(data) {
console.log("create: ", data);
SenhaModel.save(function (err, data) {
if (err) return console.log('ERRO: ', err);
return console.log('Inseriu:', data);
});
},
retrieve: function(query) {
Schema
.virtual('name.full')
.get(function (){
return this.name.first + ' ' + this.name.last;
});
Model.findById(query, function (err, data) {
if (err) return console.log('ERRO: ', err);
return console.log('Nome: ', data.name.full, '\nSenha: ', data.password);
});
},
update: function(query, mod, options) {
var options = options || {};
Model.update(query, mod, options, function (err, data) {
if (err) return console.log('ERRO: ', err);
return console.log('Alterou:', data);
});
},
delete: function(query) {
Model.remove(query, function (err, data) {
if (err) return console.log('ERRO: ', err);
return console.log('Deletou:', data);
});
},
};
module.exports = CRUD;
```
`schema.js`
```js
const mongoose = require('mongoose');
const Schema = mongoose.Schema;
const name = require('./fields/field-name');
const password = require('./fields/field-password');
function criaUsuario (){
const novoUsuario = new Schema({
name,
password
});
novoUsuario.methods.vaiCriptografar = function (){
const crypto = require('crypto');
//fazendo a mágica acontecer
const salt = crypto.randomBytes(128).toString('base64');
const chave = crypto.pbkdf2Sync(this.password, 'salt', 100000, 256, 'sha256');
return chave.toString('hex');
};
novoUsuario.pre('save', true, function (next, done) {
console.log('Senha SEM criptografia: ', '${this.password}');
//fazendo a mágica acontecer
this.password = this.vaiCriptografar();
console.log('\nSenha COM criptografia: ', '${this.password}');
next();
});
return mongoose.model('SenhaModel', novoUsuario);
}
module.exports = exports = criaUsuario();
```
`model.js`
```js
module.exports = function (Schema, ModelName) {
const mongoose = require('mongoose');
return mongoose.model(ModelName, Schema);
};
```
`fields`
```js
//field-name
module.exports = {
first: {type: String, match: /^./i},
last: {type: String, match: /^./i}
},{
toObject: {virtuals: true},
toJSON: {virtuals: true}
}
//field-password
module.exports = {type: String, match: /^./i}
```
`config.js`
```js
const mongoose = require('mongoose');
const dbURI = 'mongodb://localhost/bancoTeste';
mongoose.connect(dbURI);
mongoose.connection.on('connected', function () {
console.log('Mongoose default connection connected to ' + dbURI);
});
mongoose.connection.on('error',function (err) {
console.log('Mongoose default connection error: ' + err);
});
mongoose.connection.on('disconnected', function () {
console.log('Mongoose default connection disconnected');
});
mongoose.connection.on('open', function () {
console.log('Mongoose default connection is open');
});
process.on('SIGINT', function() {
mongoose.connection.close(function () {
console.log('Mongoose default connection disconnected through app termination');
process.exit(0);
});
});
```
Saída no terminal:
```
Senha SEM criptografia: 123456987
Senha COM criptografia: B4FBE57144DF88EEE69838FEE592DFE7FC250722CBCDB217CC89E67295FD8073
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 08 - Exercício
**User:** [gkal19](https://github.com/gkal19)
**Autor:** Gabriel Kalani
**Data** 1465801860
#### 1 - Insira 5 pokemons novos, na coleção pokemons, escolha 3 e os adicione em um array e uma nova coleção chamada meus-pokemons, utilizando o ObjectId. Adicione o required em campos que ache obrigatório no Schema do Pokemon.
```js
'use strict';
const mongoose = require('mongoose');
const dbURI = 'mongodb://localhost/be-mean-pokemons';
mongoose.connect(dbURI);
const Schema = mongoose.Schema;
const _schema = {
name: {type: String, required: true, match: /^./i},
description: {type: String, required: true, match: /^./i},
type: {type: String, required: true, match: /^./i},
attack: {type: Number, min: 1},
height: {type: Number}
};
const PokemonSchema = new Schema(_schema);
const PokemonModel = mongoose.model('pokemons', PokemonSchema);
const data = [
{
name: 'Harry James Potter',
description: 'Harry James Potter',
type: 'bruxo',
attack: 76,
height: 1.7
},
{
name: 'Hermione Granger',
description: 'Hermione Granger',
type: 'bruxa',
attack: 105,
height: 2.3
},
{
name: 'Ronald Weasley',
description: 'Ronald Weasley',
type: 'bruxo',
attack: 153,
height: 1.6
},
{
name: 'Neville Longbottom',
description: 'Neville Longbottom',
type: 'bruxo',
attack: 51,
height: 1.7
},
{
name: 'Luna Lovegood',
description: 'Luna Lovegood',
type: 'bruxa',
attack: 99,
height: 1.7
},
];
PokemonModel.create(data, (err, data) => {
if (err) return console.log('Erro: ', err);
console.log('Inserido(s): ', data);
});
```
#### Escolher 3 pokemons e inserindo em uma nova coleção com o ObjectId.
```js
'use strict';
const mongoose = require('mongoose');
const dbURI = 'mongodb://localhost/be-mean-instagram';
mongoose.connect(dbURI);
const Schema = mongoose.Schema;
const _schema = {
pokemons: [{type: Schema.Types.ObjectId, ref: 'pokemons'}]
};
const PokemonSchema = new Schema(_schema);
const PokemonModel = mongoose.model('myPokemons', PokemonSchema);
const data = {
pokemons: ['575c12969d2f2ed60edbb52b', '575c12969d2f2ed60edbb52c', '575c12969d2f2ed60edbb52d']
};
PokemonModel.create(data, (err, data) => {
if (err) return console.log('Erro: ', err);
console.log('Inserido(s): ', data);
});
```
#### 2 - Crie um Schema de exemplo com validação para os campos (utilizar Arquitetura Atômica, ou seja cada campo sendo um Schema separado):
> Os campos utilizados serão: CPF, E-mail, CNPJ, URL e IP.
`app.js`
```js
'use strict';
require('./db/config');
const CRUD = require('./controller');
const data = {
email: 'gabrielsilva1956@gmail.com',
cpf: 12345678,
cnpj: 123456,
url: 'www.gabrielkalani.com.br',
ip: '192.168.0.1'
};
CRUD.create(data);
```
`schema.js`
```js
const mongoose = require('mongoose');
const Schema = mongoose.Schema;
const email = require('./fields/field-email');
const cpf = require('./fields/field-cpf');
const cnpj = require('./fields/field-cnpj');
const url = require('./fields/field-url');
const ip = require('./fields/field-ip');
const _schema = {
email,
cpf,
cnpj,
url,
ip
};
module.exports = new Schema(_schema);
```
`model.js`
```js
module.exports = function (Schema, ModelName) {
const mongoose = require('mongoose');
return mongoose.model(ModelName, Schema);
};
```
`controller.js`
```js
'use strict';
const Schema = require('./schema');
const Model = require('./model')(Schema, 'atomicos');
const CRUD = {
create(data) {
console.log("create: ", data);
const AmoticosModel = new Model(data);
AmoticosModel.save((err, data) => {
if (err) return console.log('ERRO: ', err);
return console.log('Inseriu:', data);
});
},
retrieve(query) {
Model.find(query, (err, data) => {
if (err) return console.log('ERRO: ', err);
return console.log('Buscou:', data);
});
},
update(query, mod, options) {
var options = options || {};
Model.update(query, mod, options, (err, data) => {
if (err) return console.log('ERRO: ', err);
return console.log('Alterou:', data);
});
},
delete(query) {
Model.remove(query, (err, data) => {
if (err) return console.log('ERRO: ', err);
return console.log('Deletou:', data);
});
},
};
module.exports = CRUD;
```
`fields`
```js
//field-email.js
module.exports = {
type: String,
match:
[
/^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/,
'Preencha um e-mail válido!'
],
required: true
}
//field-cpf.js
module.exports = {type: Number, minlength: 3, maxlength: 11, required: true}
//field-cnpj.js
module.exports = {type: Number, minlength: 3}
//field-url.js
module.exports = {type: String, required: true, match: /([\w-]+\.)+[\w-]+(\/[\w- .\/?%&=]*)?/}
//field-ip.js
module.exports = {type: String, maxlenght: 15}
```
Saída no terminal:
```
$ node app.js
create: { email: 'gabrielsilva1956@gmail.com',
cpf: 12345678,
cnpj: 123456,
url: 'www.gabrielkalani.com.br',
ip: '192.168.0.1' }
Mongoose default connection connected to mongodb://localhost/be-mean-instagram
Mongoose default connection is open
Inseriu: { _id: 56d84cfdac419e351638ase0,
ip: '192.168.0.1',
url: 'www.gabrielkalani.com.br',
cnpj: 123456,
cpf: 12345678,
email: 'gabrielsilva1956@gmail.com',
__v: 0 }
```
#### 3 - Dê 3 exemplos diferentes, de cada, utilizando as funções:
`findAndModify`,`findOneAndUpdate` e `findOneAndRemove`.
#### Schema e Model
```js
'use strict';
const mongoose = require('mongoose');
const db = 'mongodb://localhost/be-mean-instagram';
mongoose.connect( db );
const Schema = mongoose.Schema;
const _schema = {
name: { type: String, required: true, match: /^./i },
description: { type: String, required: true, match: /^./i},
type: { type: String, required: true, match: /^./i},
attack: { type: Number, min: 1}
};
const PokemonSchema = new Schema(_schema);
const Model = mongoose.model('pokemons', PokemonSchema);
```
#### findAndModify
```js
'use strict';
const mongoose = require( 'mongoose' );
const db = 'mongodb://localhost/be-mean-instagram';
mongoose.connect(db);
const Schema = mongoose.Schema;
const _schema = {
name: {type: String, match: /^./i},
description: {type: String, match: /^./i},
type: {type: String, match: /^./i},
attack: {type: Number, min: 1}
};
const PokemonSchema = new Schema(_schema);
PokemonSchema.statics.findAndModify = function (query, sort, doc, options, callback) {
return this.collection.findAndModify(query, sort, doc, options, callback);
};
const Model = mongoose.model('pokemons', PokemonSchema);
const query = { attack: {$lte: 5 } };
const mod = { type: 'eletric' };
const options = { multi: true };
Model.findAndModify(query, [], mod, options, (err, data) => {
if (err) return console.log('Erro: ', err);
return console.log('Alterado: ', data);
});
// Output Terminal
Alterado: { value: null, ok: 1 }
```
#### findOneAndUpdate
##### Exemplo 1
```js
const query = { name: /Pikachu/i};
const mod = { type: 'Electric' };
Model.findOneAndUpdate(query, mod, {}, (err, data) => {
if (err) return console.log('Erro: ', err);
return console.log('Alterado: ', data);
})
// Output Terminal
Alterado: { value: null, ok: 1 }
```
##### Exemplo 2
```js
const query = { attack: {$lte: 10}};
const mod = {attack: 50};
const options = {multi: true};
Model.findOneAndUpdate(query, mod, options, (err, data) => {
if (err) return console.log('Erro: ', err);
return console.log('Alterado: ', data);
});
//Output Terminal
Alterado: { value: null, ok: 1 }
```
##### Exemplo 3
```js
const query = {$and: [{type: 'fire'}, {attack: {$gte: 5}}]};
const mod = {attack: 51, description: 'update attack'};
const options = {multi: true};
Model.findOneAndUpdate(query, mod, options, (err, data) => {
if (err) return console.log('Erro: ', err);
return console.log('Alterado: ', data);
});
//Output Terminal
Alterado: { value: null, ok: 1 }
```
#### findOneAndRemove
##### Exemplo 1
```js
const query = { attack: null };
Model.findOneAndRemove(query, (err, data) => {
if (err) return console.log('Erro: ', err);
return console.log('Removeu: ', data);
});
//Output
Removido: { value: null, ok: 1 }
```
##### Exemplo 2
```js
const query = { $and: [{type: 'grass'}, {attack: {$gte: 100}}]};
Model.findOneAndRemove(query, (err, data) => {
if (err) return console.log('Erro: ', err);
return console.log('Removeu: ', data);
});
//Output
Removido: { value: null, ok: 1 }
```
##### Exemplo 3
```js
const query = {attack: {$lte: 10}};
Model.findOneAndRemove(query, (err, data) => {
if (err) return console.log('Erro: ', err);
return console.log('Removeu: ', data);
});
//Output
Removido: { value: null, ok: 1 }
```
#### 4 - Crie 1 Schema com todo CRUD funcional e métodos especiais, que agrupe:
> virtuals, getters & setters, method & static, embedded, document ,plugins, middlewares.
<br>
> Primeiramente criei um json com o nome de 5 bruxos da série Harry Potter e os importei para o banco `be-mean-instagram`:
```json
{name: {first: 'Harry', last: 'Potter'}, age: 36, type: 'Student'}
{name: {first: 'Hermione', last: 'Granger'}, age: 36, type: 'Student'}
{name: {first: 'Ronald', last: 'Weasley'}, age: 37, type: 'Student'}
{name: {first: 'Luna', last: 'Lovegood'}, age: 35, type: 'Student'}
{name: {first: 'Alvus', last: 'Dumbledore'}, age: 135, type: 'Master'}
```
```js
// app.js
'use strict';
require('./db/config');
const CRUD = require('./controller');
const hab1 = {
title: 'Abaffiato',
since: 2005
};
const hab2 = {
title: 'Liberacorpus',
since: 1999
};
const hab3 = {
title: 'Levicorpus',
since: 2001
};
const data = {
name: {
first: 'Severo',
last: 'Snape'
},
age: 38,
skills: [hab1, hab2, hab3],
type: 'Master'
};
CRUD.create(data);
// Search
const query = "575c32ed6cc3d63b8a6d5f0f";
CRUD.retrieve(query);
// Method Searc
const query = {name: {first: 'Harry', last: 'Potter'}, class: /Student/i};
CRUD.retrieve_method(query);
// Static Search
const query = {name: {first: 'Alvus', last: 'Dumbledore'}};
CRUD.retrieve_static(query);
// Pre-Count Middleware Search
const query = {age: 37};
CRUD.retrieve_middleware(query);
```
```js
// Controller.js
'use strict';
const mongoose = require('mongoose');
const Schema = require('./schema');
const Model = require('./model')(Schema, 'bruxos');
const CRUD = {
create(data) {
console.log("Criado: ", data);
const bruxoModel = new Model(data);
bruxoModel.save((err, data) => {
if (err) return console.log('ERRO: ', err);
return console.log('Inseriu:', data);
});
},
retrieve(query) {
Schema
.virtual('name.full')
.get(function (){
return `${this.name.first} ${this.name.last}`;
});
Model.findById(query, (err, data) => {
if (err) return console.log('ERRO: ', err);
return console.log('Nome: ', data.name.full, '\nTipo de bruxo: ', data.weight_class, '\nIdade: ', data.age);
});
},
retrieve_method(query) {
Schema.methods.findSimilarType = function findSimilarType (callback) {
return this.model('Categoria', Schema);
};
const MethodModel = mongoose.model('MethodModel', Schema);
const outrobruxo = new MethodModel(query);
},
retrieve_static(query) {
Schema.statics.search = function (name, callback) {
return this.where('name', new RegExp(name, 'i')).exec(callback);
};
const StaticModel = mongoose.model('StaticModel', Schema);
},
retrieve_middleware(query) {
const countQuery = Model.where(query).count((err, count) => {
if (err) return console.log('ERRO: ', err);
return console.log(`Existem ${count} bruxos com a mesma idade!`);
});
},
update(query, mod, options) {
var options = options || {};
Model.update(query, mod, options, (err, data) => {
if (err) return console.log('ERRO: ', err);
return console.log('Alterado:', data);
});
},
delete(query) {
Model.remove(query, (err, data) => {
if (err) return console.log('ERRO: ', err);
return console.log('Deletado:', data);
});
},
};
module.exports = CRUD;
```
##### Resultado
```shell
[nodemon] starting `node app.js`
Criado: { name: { first: 'Severo', last: 'Snape' },
age: 38,
skills:
[ { title: 'Abaffiato', since: 2005 },
{ title: 'Liberacorpus', since: 1999 },
{ title: 'Levicorpus', since: 2001 } ],
type: 'Master' }
Mongoose default connection connected to mongodb://localhost/be-mean-instagram
Mongoose default connection is open
Nome: Harry Potter
Tipo de bruxo: undefined
Idade: 36
Existem 2 bruxos com a mesma idade!
Inseriu: { name: { last: 'Snape', first: 'Severo' },
skills:
[ { _id: 575c488ae3ab5d5d172c4273,
since: 2005,
title: 'Abaffiato' },
{ _id: 575c488ae3ab5d5d172c4272,
since: 1999,
title: 'Liberacorpus' },
{ _id: 575c488ae3ab5d5d172c4271,
since: 2001,
title: 'Levicorpus' } ],
created_at: Sat Jun 11 2016 17:21:14 GMT+0000 (UTC),
_id: 575c488ae3ab5d5d172c4270,
type: 'Master',
age: 38,
__v: 0 }
```
#### 5 - Crie 1 Schema para password com criptografia e arquitetura atômica.
> use SHA256 com SALT como criptografia;use middleware com pre-save;use methods.
> O código aqui iria ficar grande demais e sem querer, exclui um bocado de arquivos responsáveis pelo resultado. Então colocarei o resultado que compilou corretamente:
```shell
Senha Inserida: gabrielkalani
Senha Criptografada: e895d4f51ccd9b2aa46196b833346752d089bdb38fccd50a2ab1c0451ceee34e | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 08 - Exercício
**user:** [tuchedsf](https://github.com/tuchedsf)
**autor:** Diego Ferreira
## Exercícios Aula 8
### 1- Insira 5 pokemons novos, na coleção `pokemons`, escolha 3 e os adicione em um array e uma nova coleção chamada `meus-pokemons`, utilizando o `ObjectId`. Adicione o `required` em campos que ache obrigatório no *Schema* do Pokemon.
model.js
```js
'use strict';
module.exports = function(Schema, ModelName) {
const mongoose = require('mongoose');
return mongoose.model(ModelName, Schema);
}
```
Pokemon-schema.js
```js
'use strict';
const mongoose = require('mongoose');
const Schema = mongoose.Schema;
const name = require('../fields/field-name');
const description = require('../fields/field-description');
const attack = require('../fields/field-attack');
const defense = require('../fields/field-defense');
const height = require('../fields/field-height');
const cor = require('../fields/field-cor');
const created_at = require('../fields/field-created_at');
const _schema = new Schema({
name,
description,
attack,
defense,
height,
cor,
created_at
});
//exportando o schema para poder ser visivel
module.exports = exports = _schema;
```
####Fields (Abaixo apenas os fields com required true, para não ficar maior ainda o exercício)
field-cor.js
```js
module.exports = {type: String, enum: ['Red', 'Blue', 'Green'], required:true};
```
field-name.js
```js
module.exports = {type : String, required:true};
```
field-description.js
```js
module.exports = {type: String, minlength : 5, maxlength : 50, required: true};
```
Pokemon-controller.js
```js
'use strict';
const PokemonSchema = require('../model/schema/Pokemon-schema');
const Model = require('../model/model')(PokemonSchema,'Pokemon');
const error = require('../util/func_error');
const success = require('../util/func_success');
const CRUD = {
create : function (data) {
Model.create(data).then(success , error);
},
retrive : function (query) {
let promise = Model.find(query).exec();
promise.then(success, error);
},
update : function (query,mod, options) {
options = options || {} //{ multi: true }
let promise = Model.update(query,mod, options).exec();
promise.then(success, error);
},
delete : function (query) {
Model.remove(query).then(success , error);
}
}
module.exports = CRUD;
```
app.js (Adicionando 5 pokemons)
```js
'use strict';
require('./db/config');
const CRUD = require('./controller/Pokemon-controller');
const array = [
{
name : "Yoytubemon",
description: "engana os pokes projetando videos na tela",
attack: 95,
defense : 20,
height : 1,
cor: "Red"
},
{
name : "Gramosauro",
description: "Pokemon especialista em grama",
attack: 40,
defense : 30,
height : 0.4,
cor: "Green"
},
{
name : "SublimeTextmon",
description: "Pokemon especialista em comandos sublime",
attack: 82,
defense : 60,
height : 0.5,
cor: "Blue"
},
{
name : "BE-MEANMON",
description: "Pokemon especialista fullstak MEAN",
attack: 95,
defense : 80,
height : 3,
cor: "Blue"
},
{
name : "SublimeTextmon",
description: "Pokemon especialista em grama",
attack: 82,
defense : 60,
height : 0.5,
cor: "Green"
},
{
name: "Poke atom",
description: "Pokemon criado no atom design",
attack: 95,
defense : 84,
height : 2,
cor: 'Blue'
}
]
CRUD.create(array);
```
Saida Terminal
```
MacBook-Air-Diego:8mongoose-atomic diego$ node app.js
Mongo default connection connected to mongodb://localhost/be-mean-instagram
Mongo default connection open
[ { created_at: Sun May 15 2016 10:26:53 GMT-0300 (BRT),
_id: 5738791dbf16d8dd3bf3d227,
cor: 'Red',
height: 1,
defense: 20,
attack: 95,
description: 'engana os pokes projetando videos na tela',
name: 'Yoytubemon',
__v: 0 },
{ created_at: Sun May 15 2016 10:26:53 GMT-0300 (BRT),
_id: 5738791dbf16d8dd3bf3d228,
cor: 'Green',
height: 0.4,
defense: 30,
attack: 40,
description: 'Pokemon especialista em grama',
name: 'Gramosauro',
__v: 0 },
{ created_at: Sun May 15 2016 10:26:53 GMT-0300 (BRT),
_id: 5738791dbf16d8dd3bf3d229,
cor: 'Blue',
height: 0.5,
defense: 60,
attack: 82,
description: 'Pokemon especialista em comandos sublime',
name: 'SublimeTextmon',
__v: 0 },
{ created_at: Sun May 15 2016 10:26:53 GMT-0300 (BRT),
_id: 5738791dbf16d8dd3bf3d22a,
cor: 'Blue',
height: 3,
defense: 80,
attack: 95,
description: 'Pokemon especialista fullstak MEAN',
name: 'BE-MEANMON',
__v: 0 },
{ created_at: Sun May 15 2016 10:26:53 GMT-0300 (BRT),
_id: 5738791dbf16d8dd3bf3d22b,
cor: 'Green',
height: 0.5,
defense: 60,
attack: 82,
description: 'Pokemon especialista em grama',
name: 'SublimeTextmon',
__v: 0 },
{ created_at: Sun May 15 2016 10:26:53 GMT-0300 (BRT),
_id: 5738791dbf16d8dd3bf3d22c,
cor: 'Blue',
height: 2,
defense: 84,
attack: 95,
description: 'Pokemon criado no atom design',
name: 'Poke atom',
__v: 0 } ]
```
####Meus pokemons
Field-meusPokemons.js
```js
module.exports = (Schema) => {
return [{type: Schema.Types.ObjectId, ref: 'Pokemons'}];
}
```
Meus-pokemons-schema.js
```js
'use strict';
const mongoose = require('mongoose');
const Schema = mongoose.Schema;
const name = require('../fields/field-name');
const meusPokemons = require('../fields/field-meusPokemons')(Schema);
const created_at = require('../fields/field-created_at');
const _schema = new Schema({
name,
meusPokemons,
created_at
});
module.exports = exports = _schema;
```
Meus-pokemons-controller.js
```js
'use strict';
const MeusPokemonSchema = require('../model/schema/Meus-pokemons-schema');
const Model = require('../model/model')(MeusPokemonSchema,'Meus-Pokemons');
const error = require('../util/func_error');
const success = require('../util/func_success');
const CRUD = {
create : function (data) {
Model.create(data).then(success , error);
},
retrive : function (query) {
let promise = Model.find(query).exec();
promise.then(success, error);
},
update : function (query,mod, options) {
options = options || {} //{ multi: true }
let promise = Model.update(query,mod, options).exec();
promise.then(success, error);
},
delete : function (query) {
Model.remove(query).then(success , error);
}
}
module.exports = CRUD;
```
app.js (adicionando 3 pelo objectid)
```js
'use strict';
require('./db/config');
const CRUD = require('./controller/Pokemon-controller');
const MeusPokemonsController = require('./controller/Meus-pokemons-controller');
const data = {
name: 'Minha Nova Coleção',
meusPokemons: ['57294bdfb6de032bd6811516', '5738791dbf16d8dd3bf3d228','57256bacb6315cbdb70fc87e']
}
MeusPokemonsController.create(data);
```
Saida Terminal
```
MacBook-Air-Diego:8mongoose-atomic diego$ node app.js
Mongo default connection connected to mongodb://localhost/be-mean-instagram
Mongo default connection open
{ meusPokemons:
[ 57294bdfb6de032bd6811516,
5738791dbf16d8dd3bf3d228,
57256bacb6315cbdb70fc87e ],
created_at: Sun May 15 2016 10:47:46 GMT-0300 (BRT),
_id: 57387e028922acff3c43ab3a,
name: 'Minha Nova Coleção',
__v: 0 }
```
### 2 - Crie um *Schema* de exemplo com validação para os campos (utilizar Arquitetura Atômica, ou seja cada campo sendo um Schema separado):
* email
* cpf
* cnpj
* url
* ip
field-email.js
```js
'use strict';
const _set = (v) => v.toLowerCase();
const _validate = (email) => /ˆ\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/.test(email);
const _index = true;
const _field_email = {
type: String,
set: _set,
trim: true,
unique: true,
index: _index,
validate: [_validate, "E-mail inválido: ({VALUE}) - Padrão: xxx@xxx.com"],
required : true
};
module.exports = _field_email;
```
field-cpf.js
```js
'use strict';
const _validate = (cpf) => /^[\d]{3}\.[\d]{3}\.[\d]{3}\-[\d]{2}$/.test(cpf);
const _index = true;
const field_cpf = {
type: String,
unique: true,
index: _index,
validate: [_validate, "CPF inválido: ({VALUE}) - Formato: 000.000.000-00"],
};
module.exports = field_cpf;
```
field-cnpj.js
```js
'use strict';
const _validate = (cnpj) => /^\d{2}\.\d{3}\.\d{3}\/\d{4}\-\d{2}$/.test(cnpj);
const _index = true;
const field_cnpj = {
type: String,
unique: true,
index: _index,
validate: [_validate, "CNPJ inválido: ({VALUE})"],
};
module.exports = field_cnpj;
```
field-url.js
```js
'use strict';
const _validate = (url) => /(http|ftp|https):\/\/[\w-]+(\.[\w-]+)+([\w.,@?^=%&:\/~+#-]*[\w@?^=%&\/~+#-])?/.test(url);
const field_url = {
type: String,
validate: [_validate, "Url inválida: ({VALUE}) - nao coleque http"],
};
module.exports = field_url;
```
field-ip.js
```js
'use strict';
const _validate = (ip) => /^(((1?[1-9]?|10|2[0-4])\d|25[0-5])($|\.(?!$))){4}$/.test(ip);
const field_ip = {
type: String,
validate: [_validate, "IP inválido: ({VALUE})"],
};
module.exports = field_ip;
```
schema.js
```js
'use strict';
const mongoose = require('mongoose');
const Schema = mongoose.Schema;
const name = require('../fields/field-email');
const cpf = require('../fields/field-cpf');
const cnpj = require('../fields/field-cnpj');
const url = require('../fields/field-url');
const ip = require('../fields/field-ip');
const _schema = new Schema({
email,
cpf,
cnpj,
url,
ip
});
module.exports = exports = _schema;
```
### 3 - Dê 3 exemplos **diferentes**, de cada, utilizando as funções:
####`findAndModify`
####`findOneAndUpdate`
####`findOneAndRemove`
Para este exercício fora utilizados os arquivos do exercício 1, pokemons, e re-colocados apenas os arquivos que foram modificados:
Os arquivos schema e controller abaixo foram alterados para contemplarem os 3 comandods:
Schema.js
```js
'use strict';
const mongoose = require('mongoose');
const util = require('util');
const Schema = mongoose.Schema;
const name = require('../fields/field-name');
const description = require('../fields/field-description');
const attack = require('../fields/field-attack');
const defense = require('../fields/field-defense');
const height = require('../fields/field-height');
const cor = require('../fields/field-cor');
const created_at = require('../fields/field-created_at');
const _schema = new Schema({
name,
description,
attack,
defense,
height,
cor,
created_at
});
// findAndModify
_schema.statics.findAndModify = function (query, sort, doc, options, callback) {
return this.collection.findAndModify(query, sort, doc, options, callback);
};
//exportando o schema para poder ser visivel no controlador
module.exports = exports = _schema;
```
Pokemon-controller.js
```js
'use strict';
// aposntamento para o arquivo com a definição do schema
const PokemonSchema = require('../model/schema/Pokemon-schema');
//const pokemonModel = mongoose.model('pokemons', PokemonSchema);
// apontamento para o model e passando o schema como parametro.
const Model = require('../model/model')(PokemonSchema,'Pokemon');
const error = require('../util/func_error');
const success = require('../util/func_success');
const CRUD = {
create : function (data) {
Model.create(data).then(success , error);
},
retrive : function (query) {
//const query = {$and :[{attack : 40}, {defense : 40}]}
let promise = Model.find(query).exec();
promise.then(success, error);
},
update : function (query,mod, options) {
//const queryUpdate = {"_id" : "572f4a42cf4c206bfcaa7480"}
//const mod = {name: "Poke Promise", defense : 50}
options = options || {} //{ multi: true }
let promise = Model.update(query,mod, options).exec();
promise.then(success, error);
},
delete : function (query) {
//const queryDelete = {"_id" : "572f4a42cf4c206bfcaa7480"}
Model.remove(query).then(success , error);
},
findAndModify: function(query, mod, opt){
Model.findAndModify(query, [], mod, opt, function (err, data) {
if (err) return console.log('Erro: ', err);
return console.log('Alterou: ', data);
});
},
findOneAndUpdate: function (query, mod, opt) {
Model.findOneAndUpdate(query, mod, opt, function (err, data) {
if (err) return console.log('Erro: ', err);
return console.log('Alterou: ', data);
});
},
findOneAndRemove: function (query) {
Model.findOneAndRemove(query, function (err, data) {
if (err) return console.log('Erro: ', err);
return console.log('Removeu: ', data);
});
}
}
module.exports = CRUD;
```
- findAndModify
FindAndModify fiz com base no stackoverflow pois pela documentação do mongoose (http://mongoosejs.com/docs/api.html#query-js) este comando é feito atraves do findOneAndUpdate, findOneAndRemove, etc...
app.js - com chamada ao método
```js
'use strict';
//apontamento arquivo configuracao banco de dados.
require('./db/config');
const CRUD = require('./controller/Pokemon-controller');
const MeusPokemonsController = require('./controller/Meus-pokemons-controller');
const query = {defense : 30}
const mod = {defense: 32};
const opt = {multi: true};
CRUD.findAndModify(query,mod,opt);
const query = {defense : 32}
const mod = {defense: 30};
const opt = {multi: true};
CRUD.findAndModify(query,mod,opt);
```
Resultado
```
MacBook-Air-Diego:8mongoose-atomic diego$ node app.js
Mongo default connection connected to mongodb://localhost/be-mean-instagram
Mongo default connection open
Alterou: { lastErrorObject: { updatedExisting: true, n: 1 },
value:
{ _id: 57256bacb6315cbdb70fc87e,
name: 'Tuchemon',
description: 'Tartaruga tuche',
type: 'reptile',
defense: 30,
height: 20,
attack: 0,
__v: 0 },
ok: 1 }
MacBook-Air-Diego:8mongoose-atomic diego$ node app.js
Mongo default connection connected to mongodb://localhost/be-mean-instagram
Mongo default connection open
Alterou: { lastErrorObject: { updatedExisting: true, n: 1 },
value: { _id: 57256bacb6315cbdb70fc87e, defense: 32 },
ok: 1 }
```
- findOneAndUpdate
app.js
```js
'use strict';
//apontamento arquivo configuracao banco de dados.
require('./db/config');
const CRUD = require('./controller/Pokemon-controller');
const MeusPokemonsController = require('./controller/Meus-pokemons-controller');
console.log("Exemplo 1");
const query = {name: /SublimeTextmon/i};
const mod = {cor: 'Red'};
const opt = {};
CRUD.findOneAndUpdate(query,mod,opt);
console.log("Exemplo 2");
const query2 = {$and : [{name: /SublimeTextmon/i}, {cor : 'Green'}]};
const mod2 = {cor: 'Red'};
CRUD.findOneAndUpdate(query2,mod2,opt);
console.log("Exemplo 3");
const query3 = {height: {$lt : 2} };
const mod3 = {height: 2.05};
CRUD.findOneAndUpdate(query3,mod3,opt);
```
Resultado
```
MacBook-Air-Diego:8mongoose-atomic diego$ node app.js
Exemplo 1
Exemplo 2
Exemplo 3
Mongo default connection connected to mongodb://localhost/be-mean-instagram
Mongo default connection open
Alterou: { created_at: Sun May 15 2016 10:26:53 GMT-0300 (BRT),
__v: 0,
cor: 'Blue',
height: 0.5,
defense: 60,
attack: 82,
description: 'Pokemon especialista em comandos sublime',
name: 'SublimeTextmon',
_id: 5738791dbf16d8dd3bf3d229 }
Alterou: { created_at: Sun May 15 2016 10:26:53 GMT-0300 (BRT),
__v: 0,
cor: 'Green',
height: 0.5,
defense: 60,
attack: 82,
description: 'Pokemon especialista em grama',
name: 'SublimeTextmon',
_id: 5738791dbf16d8dd3bf3d22b }
Alterou: { created_at: Tue May 03 2016 22:09:51 GMT-0300 (BRT),
__v: 0,
cor: 'Green',
height: 0.4,
defense: 30,
attack: 40,
description: 'Pokemon especialista em grama',
name: 'Gramosauro',
_id: 57294bdfb6de032bd6811516 }
```
- findOneAndRemove
app.js
```js
'use strict';
//apontamento arquivo configuracao banco de dados.
require('./db/config');
const CRUD = require('./controller/Pokemon-controller');
const MeusPokemonsController = require('./controller/Meus-pokemons-controller');
console.log("Exemplo 1");
const query = {name: /SublimeTextmon/i};
CRUD.findOneAndRemove(query);
console.log("Exemplo 2");
const query2 = {cor : 'Green'};
CRUD.findOneAndRemove(query2);
console.log("Exemplo 3");
const query3 = {height: {$lt : 2} };
CRUD.findOneAndRemove(query3);
```
Resultado
```
MacBook-Air-Diego:8mongoose-atomic diego$ node app.js
Exemplo 1
Exemplo 2
Exemplo 3
Mongo default connection connected to mongodb://localhost/be-mean-instagram
Mongo default connection open
Removeu: { created_at: Sun May 15 2016 10:26:53 GMT-0300 (BRT),
__v: 0,
cor: 'Red',
height: 0.5,
defense: 60,
attack: 82,
description: 'Pokemon especialista em comandos sublime',
name: 'SublimeTextmon',
_id: 5738791dbf16d8dd3bf3d229 }
Removeu: { created_at: Tue May 03 2016 22:09:51 GMT-0300 (BRT),
__v: 0,
cor: 'Green',
height: 2.05,
defense: 30,
attack: 40,
description: 'Pokemon especialista em grama',
name: 'Gramosauro',
_id: 57294bdfb6de032bd6811516 }
Removeu: { created_at: Wed May 18 2016 11:16:39 GMT-0300 (BRT),
cor: 'Blue',
height: 0.7,
defense: 40,
attack: 40,
description: 'Pokemon que altera inserindo',
name: 'Nerdmon',
_id: 57294fe05daea5abb1cb1c4f }
```
### 4 - Crie 1 *Schema* com todo CRUD funcional e métodos especiais, que agrupe:
* virtuals;
* getters & setters;
* method & static;
* embedded document;
* plugins;
* middlewares.
config
```js
//importar o mongoose
const mongoose = require('mongoose');
const uriDB = 'mongodb://localhost/lista-livros';
//criar uma conexão com mongo
mongoose.connect(uriDB);
mongoose.connection.on('connected', function(){
console.log("Mongo default connection connected to " + uriDB);
});
mongoose.connection.on('error', function(err){
console.log("Mongo default connection error" + err);
});
mongoose.connection.on('disconnected', function(){
console.log("Mongo default connection disconnected");
});
mongoose.connection.on('open', function(){
console.log("Mongo default connection open");
});
process.on('SIGINT',function(){
mongoose.connection.close(function(){
console.log("The connection is closed");
process.exit(0);
});
});
```
actions
```js
//action-create.js
'use strict';
const callback = require('./callback');
module.exports = (Model, obj, coment) => {
let livro = new Model(obj);
if (coment.titulo != null) {
livro.comentariosLeitores.push( coment );
}
Model.create(livro, callback);
}
//action-find.js
'use strict';
const callback = require('./callback');
module.exports = (Model, query) => {
Model.find(query, callback);
}
//action-findOne.js
'use strict';
const callback = require('./callback');
module.exports = (Model, query) => {
Model.findOne(query, callback);
};
//action-findTituloCompleto.js
'use strict';
module.exports = (Model, id) => {
Model.findById(id, (err,data) => {
if (err) console.log(err);
console.log("Titulo Completo: " + data.titulo.completo);
});
};
//action-remove.js
'use strict';
const callback = require('./callback');
module.exports = (Model, query) => {
Model.remove(query, callback);
};
//action-update.js
'use strict';
const callback = require('./callback');
module.exports = (Model, query, mod, options) => {
Model.update(query,mod,options, callback);
}
//callback.js
'use strict';
module.exports = (err, data) => {
if (err) console.log('Erro:', err);
else console.log('RETORNOU:', data);
};
```
quarks
```js
//quark-matchNumber.js
module.exports = /\d/g;
//quark-toLowerCase.js
'use strict';
module.exports = (v) => v.toLowerCase();
//quark-toUpperCase.js
'use strict';
module.exports = (v) => v.toUpperCase();
//quark-val-GT0.js
'use strict';
module.exports = {
validator: (v) => v >= 0
, message: '{VALUE} precisa ser maior que 0'
};
//quark-val-numberGTE0LTE10.js
'use strict';
module.exports = {
validator: (v) => v >= 0 || v <= 10
, message: '{VALUE} precisa ser maior igual a 0 ou menor igual a 10!'
};
//quark-val-strLenghtGTE2.js
'use strict';
module.exports = {
validator: (v) => v.length >= 2
, message: '{VALUE} precisa ser maior que 2 caracteres'
};
```
atoms
```js
//atom-autor.js
'use strict';
const Atom_autor = {
type: String
, validate: require('./../quarks/quark-val-srtLenghtGTE2')
, required: true
, index: true
}
module.exports = Atom_autor;
//atom-created_at.js
'use strict';
const Atom_created_at = {
type: Date
, default: Date.now
}
module.exports = Atom_created_at;
//atom-genero.js
'use strict';
const Atom_genero = {
type: String
, set: require('./../quarks/quark-toLowerCase')
, validate: require('./../quarks/quark-val-srtLenghtGTE2')
, required: true
, index: true
}
module.exports = Atom_genero;
//atom-notaLivro.js
'use strict';
const Atom_notaLivro = {
type: Number
, default: 0
, required : true
, validate: require('./../quarks/quark-val-numberGTE0LTE10')
, match: require('./../quarks/quark-matchNumber')
}
module.exports = Atom_notaLivro;
//atom-paginas.js
'use strict';
const Atom_paginas = {
type: Number
, default: 0
, required : true
, validate: require('./../quarks/quark-val-GT0')
, match: require('./../quarks/quark-matchNumber')
}
module.exports = Atom_paginas;
//atom-resumo.js
'use strict';
const Atom_resumo = {
type: String
}
module.exports = Atom_resumo;
//atom-subtitulo.js
'use strict';
const Atom_subtitulo = {
type: String
, set: require('./../quarks/quark-toUpperCase')
}
module.exports = Atom_subtitulo;
//atom-titulo.js
'use strict';
const Atom_titulo = {
type: String
, set: require('./../quarks/quark-toUpperCase')
, validate: require('./../quarks/quark-val-srtLenghtGTE2')
, required: true
, index: true
}
module.exports = Atom_titulo;
//atom-tituloComent.js
'use strict';
const Atom_tituloComent = {
type: String
, validate: require('./../quarks/quark-val-srtLenghtGTE2')
, required: true
}
module.exports = Atom_tituloComent;
```
molecules
```js
//molecule-comentario.js
'use strict';
const mongoose = require('mongoose');
const _schema = {
titulo: require('../atoms/atom-tituloComent'),
autor: require('../atoms/atom-autor'),
notaLivro: require('../atoms/atom-paginas'),
comentario: require('../atoms/atom-resumo'),
created_at: require('../atoms/atom-created_at')
};
const comentSchema = new mongoose.Schema(_schema);
module.exports = comentSchema;
//molecule-livro.js
'use strict';
const mongoose = require('mongoose');
const comentariosSchema = require('../molecules/molecule-comentarios');
const lastMod = require('../plugins/plugin-lastModif');
const _schema = {
livro: {
titulo: require('../atoms/atom-titulo'),
subtitulo: require('../atoms/atom-subtitulo'),
},
autor: require('../atoms/atom-autor'),
paginas: require('../atoms/atom-paginas'),
genero: require('../atoms/atom-genero'),
comentariosLeitores: [comentariosSchema],
created_at: require('../atoms/atom-created_at')
};
const livroSchema = new mongoose.Schema( _schema
, { toObject: { virtuals: true }
, toJSON: { virtuals: true }
});
//virtual
livroSchema.virtual('titulo.completo').get(function () {
return this.livro.titulo + ' - ' + this.livro.subtitulo;
});
//static
livroSchema.statics.findByAutor = function (username, callback) {
this.find({ autor: new RegExp(username, 'i') }, callback);
};
//method
livroSchema.methods.findSimilarGenero = function (callback) {
return this.model('Livros').find({ genero: this.genero }, callback);
}
//plugin e middleware
livroSchema.plugin(lastMod);
module.exports = livroSchema;
```
plugins
```js
//plugin-lastModif.js
module.exports = exports = function lastModifiedPlugin (schema, options) {
schema.add({lastMod: Date })
schema.pre('save', function (next) {
this.lastMod = new Date
next()
})
if (options && options.index) {
schema.path('lastMod').index(options.index)
}
}
```
organisms
```js
//model.js
'use strict';
module.exports = function(Schema, ModelName) {
const mongoose = require('mongoose');
return mongoose.model(ModelName, Schema);
}
//organism-livros.js
'use strict';
const livrosSchema = require('../molecules/molecule-livro');
const livrosModel = require('./model')(livrosSchema,'Livros');
const CRUD = {
create: (obj, coment) => {
require('../actions/action-create')(livrosModel, obj, coment);
}
, find: (query) => {
require('../actions/action-find')(livrosModel, query);
}
, findOne: (query) => {
require('../actions/action-findOne')(livrosModel, query);
}
, update: (query, mod, options) => {
require('../actions/action-update')(livrosModel, query, mod, options);
}
, remove: (query) => {
require('../actions/action-remove')(livrosModel, query);
}
, findTituloCompletoByIdLivro: (id) => {
require('../actions/action-findTituloCompletoByIdLivro')(livrosModel, id);
}
, findByAutor: (autor) => {
livrosModel.findByAutor(autor,require('../actions/callback'));
}
, findSimilarGenero: (genero) => {
var livroBusca = new livrosModel(genero);
livroBusca.findSimilarGenero(require('../actions/callback'));
}
};
module.exports = CRUD;
```
app.js
```js
require('./config/db-config');
const livroModel = require('./organisms/organism-livros');
const comentarioModel = require('./organisms/organism-comentarios');
const comentario = { titulo: "Muito bom",autor: "Diego Ferreira",notaLivro: 10,
comentario: "Livro muito bom com ele temos uma noção e sensação de estar presente na 2 guerra"
};
const livro1 = { livro: { titulo: "Os Bebês de Auschwitz" , subtitulo: ""} , autor: "Holden, Wendy" , paginas: 368 , genero: 'Biografias e Memórias'};
const livro2 = { livro: { titulo: "A Elite da Tropa" , subtitulo: "" }, autor: "Luiz Eduardo Soares" , paginas: 230 , genero: 'Policial'};
const livro3 = { livro: { titulo: "A Elite da Tropa 2" , subtitulo: "O inimigo agora é outro" }, autor: "Luiz Eduardo Soares" , paginas: 200 , genero: 'Policial'};
const livro4 = { livro: { titulo: "O fim da pobresa" , subtitulo: "Como acabar com a miséria mundial nos próximos 20 anos" }, autor: "Jeffrey D. Sachs" , paginas: 450 , genero: 'Auto-Ajuda'};
const livro5 = { livro: { titulo: "O Menino Maluquinho" , subtitulo: "De panela na cabeça" }, autor: "Ziraldo" , paginas: 50 , genero: 'infantil'};
livroModel.create(livro1, comentario);
livroModel.find({paginas: {$gt : 300}});
livroModel.findOne({autor: "Holden, Wendy"});
const query = {paginas: {$lt : 100}};
const mod = { paginas : 62};
const options = {};
livroModel.update(query,mod,options);
const optionsMultiTrue = {multi : true};
livroModel.update(query,mod,optionsMultiTrue);
const queryRemove = {paginas : 62};
livroModel.remove(queryRemove);
//virtuals findTituloCompletoByIdLivro
livroModel.findTituloCompletoByIdLivro('5743a14679a2a7405d96c6f2');
//statics findByAutor
livroModel.findByAutor('Holden');
//method findSimilarGenero
livroModel.findSimilarGenero({genero: 'Policial'});
```
Resultado:
```
//executei apenas 1 create pela funcionalidade o restante foi import banco
////livroModel.create(livro1, comentario);
RETORNOU: { livro: { titulo: 'OS BEBÊS DE AUSCHWITZ', subtitulo: '' },
paginas: 368,
comentariosLeitores:
[ { notaLivro: 10,
created_at: Mon May 23 2016 21:30:23 GMT-0300 (BRT),
_id: 5743a09f450c7f1f5d01f1c0,
comentario: 'Livro muito bom com ele temos uma noção e sensação de estar presente na 2 guerra',
autor: 'Diego Ferreira',
titulo: 'Muito bom',
id: '5743a09f450c7f1f5d01f1c0' } ],
created_at: Mon May 23 2016 21:30:23 GMT-0300 (BRT),
autor: 'Holden, Wendy',
genero: 'biografias e memórias',
_id: 5743a09f450c7f1f5d01f1bf,
lastMod: Mon May 23 2016 21:30:23 GMT-0300 (BRT),
__v: 0,
titulo: { completo: 'OS BEBÊS DE AUSCHWITZ - ' },
id: '5743a09f450c7f1f5d01f1bf' }
//livroModel.find({paginas: {$gt : 300}});
RETORNOU: [ { livro: { titulo: 'OS BEBÊS DE AUSCHWITZ', subtitulo: '' },
paginas: 368,
comentariosLeitores: [ [Object] ],
created_at: Mon May 23 2016 21:30:23 GMT-0300 (BRT),
__v: 0,
autor: 'Holden, Wendy',
genero: 'biografias e memórias',
lastMod: Mon May 23 2016 21:30:23 GMT-0300 (BRT),
_id: 5743a09f450c7f1f5d01f1bf,
titulo: { completo: 'OS BEBÊS DE AUSCHWITZ - ' },
id: '5743a09f450c7f1f5d01f1bf' },
{ livro:
{ titulo: 'O FIM DA POBRESA',
subtitulo: 'COMO ACABAR COM A MISÉRIA MUNDIAL NOS PRÓXIMOS 20 ANOS' },
paginas: 450,
comentariosLeitores: [],
created_at: Mon May 23 2016 21:33:10 GMT-0300 (BRT),
__v: 0,
autor: 'Jeffrey D. Sachs',
genero: 'auto-ajuda',
lastMod: Mon May 23 2016 21:33:10 GMT-0300 (BRT),
_id: 5743a14679a2a7405d96c6f2,
titulo: { completo: 'O FIM DA POBRESA - COMO ACABAR COM A MISÉRIA MUNDIAL NOS PRÓXIMOS 20 ANOS' },
id: '5743a14679a2a7405d96c6f2' } ]
//livroModel.findOne({autor: "Holden, Wendy"});
RETORNOU: { livro: { titulo: 'OS BEBÊS DE AUSCHWITZ', subtitulo: '' },
paginas: 368,
comentariosLeitores:
[ { notaLivro: 10,
created_at: Mon May 23 2016 21:30:23 GMT-0300 (BRT),
_id: 5743a09f450c7f1f5d01f1c0,
comentario: 'Livro muito bom com ele temos uma noção e sensação de estar presente na 2 guerra',
autor: 'Diego Ferreira',
titulo: 'Muito bom',
id: '5743a09f450c7f1f5d01f1c0' } ],
created_at: Mon May 23 2016 21:30:23 GMT-0300 (BRT),
__v: 0,
autor: 'Holden, Wendy',
genero: 'biografias e memórias',
lastMod: Mon May 23 2016 21:30:23 GMT-0300 (BRT),
_id: 5743a09f450c7f1f5d01f1bf,
titulo: { completo: 'OS BEBÊS DE AUSCHWITZ - ' },
id: '5743a09f450c7f1f5d01f1bf' }
//livroModel.update(query,mod,options);
RETORNOU: { ok: 1, nModified: 1, n: 1 }
//livroModel.remove(queryRemove);
RETORNOU: { result: { ok: 1, n: 1 }, ... }
//livroModel.findTituloCompletoByIdLivro('5742336aed21ba1f5119e7e3');
Titulo Completo: O FIM DA POBRESA - COMO ACABAR COM A MISÉRIA MUNDIAL NOS PRÓXIMOS 20 ANOS
//livroModel.findByAutor('Holden');
RETORNOU: [ { livro: { titulo: 'OS BEBÊS DE AUSCHWITZ', subtitulo: '' },
paginas: 368,
comentariosLeitores: [ [Object] ],
created_at: Mon May 23 2016 21:30:23 GMT-0300 (BRT),
__v: 0,
autor: 'Holden, Wendy',
genero: 'biografias e memórias',
lastMod: Mon May 23 2016 21:30:23 GMT-0300 (BRT),
_id: 5743a09f450c7f1f5d01f1bf,
titulo: { completo: 'OS BEBÊS DE AUSCHWITZ - ' },
id: '5743a09f450c7f1f5d01f1bf' } ]
//livroModel.findSimilarGenero({genero: 'policial'});
RETORNOU: [ { livro:
{ titulo: 'A ELITE DA TROPA 2',
subtitulo: 'O INIMIGO AGORA É OUTRO' },
paginas: 200,
comentariosLeitores: [],
created_at: Mon May 23 2016 21:33:10 GMT-0300 (BRT),
__v: 0,
autor: 'Luiz Eduardo Soares',
genero: 'policial',
lastMod: Mon May 23 2016 21:33:10 GMT-0300 (BRT),
_id: 5743a14679a2a7405d96c6f1,
titulo: { completo: 'A ELITE DA TROPA 2 - O INIMIGO AGORA É OUTRO' },
id: '5743a14679a2a7405d96c6f1' },
{ livro: { titulo: 'A ELITE DA TROPA', subtitulo: '' },
paginas: 230,
comentariosLeitores: [],
created_at: Mon May 23 2016 21:33:10 GMT-0300 (BRT),
__v: 0,
autor: 'Luiz Eduardo Soares',
genero: 'policial',
lastMod: Mon May 23 2016 21:33:10 GMT-0300 (BRT),
_id: 5743a14679a2a7405d96c6f0,
titulo: { completo: 'A ELITE DA TROPA - ' },
id: '5743a14679a2a7405d96c6f0' } ]
```
### 5 - Crie 1 *Schema* para `password` com criptografia e arquitetura atômica.
* use SHA256 com SALT como criptografia;
* use middleware com pre save;
* use methods.
field-created_at.js
```js
module.exports = { type: Date, default: Date.now };
```
field-password.js
```js
'use strict';
const _validate = (v) => v.length >= 6 && v.length <= 10;
const _field_password = {
type: String,
validate: [ _validate, "Senha precisa ser maior que 6 e menor que 10 caracteres"],
require: true
};
module.exports = _field_password;
```
password-schema.js
```js
'use strict';
const mongoose = require('mongoose');
const crypto = require('crypto');
const password = require('../fields/field-password');
const created_at = require('../fields/field-created_at');
const _schema = {
password,
created_at
};
const PasswordSchema = new mongoose.Schema(_schema);
PasswordSchema.methods.cryptoPassword = function (){
const key = crypto.pbkdf2Sync(this.password, 'salt', 100000, 256, 'sha256');
return key.toString('hex');
};
PasswordSchema.pre('save', function( next ){
console.log("sem criptografia:" + `${this.password}` );
this.password = this.cryptoPassword();
next();
});
module.exports = PasswordSchema;
```
password-model.js
```js
'use strict';
const passwordSchema = require('../model/schemas/Password-schema');
const PasswordModel = require('../model/model')(passwordSchema,'Senha');
const save = (obj) => {
const novoObj = new PasswordModel(obj);
novoObj.save( (err,data) => {
if (err) console.log(err);
console.log("Password salvo com sucesso: " + data);
});
};
const CRUD = {
save
};
module.exports = CRUD;
```
password-controller.js
```js
'use strict';
const passwordModel = require('../model/password_model');
const CRUD = {
save : passwordModel.save
}
module.exports = CRUD;
```
app-passoword.js
```js
'use strict';
require('./db/config');
const passwordController = require('./controller/password_controller');
const obj = { password : "tuchedsf"};
passwordController.save(obj);
```
Resultado:
```
MacBook-Air-Diego:08mongoose-user diego$ node app-password.js
sem criptografia: tuchedsf
Mongo default connection connected to mongodb://localhost/mongoose-user-test
Mongo default connection open
Password salvo com sucesso: { created_at: Thu May 19 2016 21:41:49 GMT-0300 (BRT),
_id: 573e5d4dbf94a3841dd8c76b,
password: '1a0dc0b6d40feedafb73d9ca48b18ecd7c343efd8f73cd71f9b933bd8f5cfcbb4dffb86dfdd2c47329bd1e788a02bf3885c64dd231be4a326196002affc9a5a77e79606f6a56cbb6a8ad87dcabf52573da0f99f8c49a7509cd39901e320ebcc3461552793be5c63804a9cac7a37403e63721a94ce48c5199511599b6a7c56237ad2d03ace2470cab725a27fa789b374ce0287ceb44d52a84fde6733b09ceaf751e6fe48fee668fdcaa9fdf6ce89c92f5648609487d05b5643b1a63883df0cdf06063c04274461c86c1be97fa1ac4abecb26474e8c07d1046b81915dfe7bf139f52e59a053b80889543fbefd08ce300bb42916bf6d179b4e885347da1395e372c',
__v: 0 }
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 08 - Exercício
**user:** [FranciscoValerio](https://github.com/FranciscoValerio)
**autor:** Francisco Henrique Ruiz Valério
> Exercícios Aula 08 parte 02 (plugins).
1 - Crie um novo schema como nome de User, e use o plugin timestemp nele, esse schema deve ter email e password.
**Schema User criado:**
```JS
'use strict';
const mongoose = require( 'mongoose' );
const Schema = mongoose.Schema;
const timestemp = require( './plugins/timestemp' );
const userSchema = new Schema({
email: { type: String, required: true},
password: { type: String, required: true}
});
userSchema.plugin( timestemp );
module.exports = mongoose.model( 'User', userSchema );
```
2 - Crie um novo plugin que adicione o um novo campo ao schema User, o novo campo de ser O Sexo do tipo String.
**Plugin field-sexo:**
```JS
'use strict';
function fieldsexo(schema, options){
schema.add( { sexo: { type: String } } );
function preUpdate(next){
console.log('pre update has calling');
next();
}
schema.pre('update', preUpdate);
}
module.exports = fieldsexo;
```
**Schema User:**
```JS
'use strict';
const mongoose = require( 'mongoose' );
const Schema = mongoose.Schema;
const timestemp = require( './plugins/timestemp' );
const fieldsexo = require( './plugins/field-sexo' );
const userSchema = new Schema({
email: { type: String, required: true},
password: { type: String, required: true}
});
userSchema.plugin( timestemp );
userSchema.plugin( fieldsexo );
module.exports = mongoose.model( 'User', userSchema );
```
3 - Salve 5 novos Users com email, password e Sexo, vindo dos plugins.
**Fonte utilizado na gravação dos 5 usuários:**
```JS
'use strict';
const model = require( './user' );
const mongoose = require( 'mongoose' );
mongoose.connect( 'mongodb://localhost/test' );
var user1 = {
email: 'francisco@bla.com',
password: '1234',
sexo: 'M'
};
var user2 = {
email: 'henrique@ble.com',
password: '45678',
sexo: 'M'
};
var user3 = {
email: 'jujuzita@jju.com',
password: 'jujuzita',
sexo: 'F'
};
var user4 = {
email: 'adebair@abc.com',
password: 'hhhsss',
sexo: 'M'
};
var user5 = {
email: 'musum@biritis.com',
password: 'cacildis',
sexo: 'M'
};
model.create(user1, createPost );
model.create(user2, createPost );
model.create(user3, createPost );
model.create(user4, createPost );
model.create(user5, createPost );
function createPost(err, post ){
if ( err ) throw err;
else {
console.log(post);
process.exit(1);
}
}
```
```
{
_id: 56cd003d418f55fc1d01df83,
created_at: Tue Feb 23 2016 21:58:37 GMT-0300 (Hora oficial do Brasil),
update_at: Tue Feb 23 2016 21:58:37 GMT-0300 (Hora oficial do Brasil),
sexo: 'M',
password: '1234',
email: 'francisco@bla.com',
__v: 0
}
{
_id: 56cd011d4850b19410396fa9,
created_at: Tue Feb 23 2016 22:02:21 GMT-0300 (Hora oficial do Brasil),
update_at: Tue Feb 23 2016 22:02:21 GMT-0300 (Hora oficial do Brasil),
sexo: 'M',
password: '45678',
email: 'henrique@ble.com',
__v: 0
}
{
_id: 56cd015d181995241519e3df,
created_at: Tue Feb 23 2016 22:03:25 GMT-0300 (Hora oficial do Brasil),
update_at: Tue Feb 23 2016 22:03:25 GMT-0300 (Hora oficial do Brasil),
sexo: 'F',
password: 'jujuzita@jju.com',
email: 'Juju',
__v: 0
}
{
_id: 56cd0181dd5101bc01bde118,
created_at: Tue Feb 23 2016 22:04:01 GMT-0300 (Hora oficial do Brasil),
update_at: Tue Feb 23 2016 22:04:01 GMT-0300 (Hora oficial do Brasil),
sexo: 'M',
password: 'hhhsss',
email: 'adebair@abc.com',
__v: 0
}
{
_id: 56cd019fde9639f808c62d71,
created_at: Tue Feb 23 2016 22:04:31 GMT-0300 (Hora oficial do Brasil),
update_at: Tue Feb 23 2016 22:04:31 GMT-0300 (Hora oficial do Brasil),
sexo: 'M',
password: 'cacildis',
email: 'musum@biritis.com',
__v: 0
}
```
> Exercícios Aula 08 parte 04 (Middleware).
1 - Criar um middleware pre com um erro e propagar o erro para quem o chamou, salvar o result e botar no md deste exercício.
**Arquivo contendo o schema de pokemon e o error no pre:**
```JS
const mongoose = require( 'mongoose' );
const util = require( 'util' );
const Schema = mongoose.Schema;
const ObjectId = Schema.ObjectId;
const log = require( './log' );
mongoose.connect( 'mongodb://localhost/be-mean-instagram' );
function pokemonHandler(){
const schema = new Schema({
id : ObjectId,
name: { type: String, trin: true },
type: { type: String, trin: true },
attack: { type: Number },
defense: { type: Number },
height: { type: Number },
description: { type: String, trin: true }
});
schema.pre('save', next => {
util.log('before save');
const err = new Error( 'same error');
next(err);
});
return mongoose.model('Pokemon', schema);
}
module.exports = exports = pokemonHandler();
```
**Arquivo que chama o schema do pokemon:**
```JS
'use strict';
const Pokemon = require( './pokemon-error' );
const pokemon = new Pokemon( {
name: 'Francisco',
description: 'great',
type: 'fisher',
attack: 70,
defense: 99,
height: 1.85
} );
pokemon.save(err => {
if (err){
console.log(err);
}
});
```
**result:**
```
23 Feb 22:23:58 - before save
[Error: same error]
```
2 - Adicione o módulo de log, aos dois schemas do blog, e faça com que gere um arquivo blog-models.md com pelo menos 6 operações no blog save() ou delete().
**users-schema.js**
```JS
'use strict';
const mongoose = require( 'mongoose' );
const Schema = mongoose.Schema;
const Post = require( './posts-schema' );
const util = require( 'util' );
const log = require( './log' );
let userSchema = new Schema({
name: { type: String, required: true },
email: { type: String, required: true, uniq: true }
});
module.exports = mongoose.model('User', userSchema );
userSchema.post('remove', user =>{
Post.remove({ _user: user._id}.postsRemoved );
});
function postsRemoved(err, ok){
util.log(err || ok.result);
}
userSchema.post('save', user =>{
log( 'user', `${user.name} email: ${user.email} saved.` );
console.log(user);
});
```
**posts-schema.js**
```JS
'use strict';
const mongoose = require( 'mongoose' );
const Schema = mongoose.Schema;
const log = require( './log' );
let postsSchema = new Schema({
title: String,
body: String,
userEmail: String,
_user: {
type: Schema.ObjectId,
ref: 'User'
}
});
module.exports = mongoose.model('Post', postsSchema );
postsSchema.post('save', post =>{
log( 'post', `${post.title} user: ${post.userEmail} saved.` );
console.log(post);
});
```
**Arquivo blog-models.md**
```
user: Francisco email: francisco@bla.com saved.: Wed Feb 24 2016 19:09:14 GMT-0300 (Hora oficial do Brasil)
user: Henrique email: henrique@ble.com saved.: Wed Feb 24 2016 19:10:03 GMT-0300 (Hora oficial do Brasil)
post: Mongoose Middleware user: francisco@bla.com saved.: Wed Feb 24 2016 19:14:51 GMT-0300 (Hora oficial do Brasil)
post: Class 08 user: henrique@ble.com saved.: Wed Feb 24 2016 19:17:45 GMT-0300 (Hora oficial do Brasil)
post: Node.Js user: henrique@ble.com saved.: Wed Feb 24 2016 19:18:21 GMT-0300 (Hora oficial do Brasil)
post: Node.Js user: henrique@ble.com saved.: Wed Feb 24 2016 19:18:37 GMT-0300 (Hora oficial do Brasil)
post: MongoDB user: francisco@bla.com saved.: Wed Feb 24 2016 19:19:04 GMT-0300 (Hora oficial do Brasil)
post: Express user: francisco@bla.com saved.: Wed Feb 24 2016 19:19:25 GMT-0300 (Hora oficial do Brasil)
```
3 - Crie um middleware usando o exemplo do blog, para gera um log com nome titulo dos post que foi buscado "dica use o find".
**Arquivo find-blog.js**
```JS
'use strict';
const Post = require( './posts-schema' );
Post.find({userEmail: 'francisco@bla.com'}, { _id: 0, body: 0, __v: 0, _user: 0 }, () =>{});
```
**Resultado do LOG**
```
buscado:
{
title: 'Mongoose Middleware',
userEmail: 'francisco@bla.com'
},
{
title: 'Mongoose Middleware',
userEmail: 'francisco@bla.com'
},
{
title: 'Mongoose Middleware',
userEmail: 'francisco@bla.com'
},
{
title: 'Mongoose Middleware',
userEmail: 'francisco@bla.com'
},
{
title: 'Mongoose Middleware',
userEmail: 'francisco@bla.com'
},
{
title: 'Mongoose Middleware',
userEmail: 'francisco@bla.com'
},
{
title: 'Mongoose Middleware',
userEmail: 'francisco@bla.com'
},
{
title: 'MongoDB',
userEmail: 'francisco@bla.com'
},
{
title: 'Express',
userEmail: 'francisco@bla.com'
}
: Wed Feb 24 2016 20:11:17 GMT-0300 (Hora oficial do Brasil)
```
> Exercícios Aula 08 final (Geral).
1. Insira 5 pokemons novos, na coleção pokemons, escolha 3 e os adicione em um array e uma nova coleção chamada meus-pokemons, utilizando o ObjectId. Adicione o required em campos que ache obrigatório no Schema do Pokemon.
**Arquivo para inserir os pokemons**
```JS
var Mongoose = require('Mongoose');
var db = Mongoose.connection;
db.on('error', console.error);
db.once('open', function() {
console.log('Conectado.')
var pokemonSchema = new Mongoose.Schema({
name: { type: String, required: true },
attack: { type: Number, required: true },
created_at: { type: Date, default: Date.now },
active: Boolean,
hasCreditCookie: Boolean
});
pokemonSchema.statics.findAllWithCreditCookies = function(callback) {
return this.find({ hasCreditCookie: true }, callback);
};
var Pokemon = Mongoose.model('Pokemon', pokemonSchema);
for (var i =1; i<=5; i++){
var pokemon = new Pokemon({
name: 'Pokemon ' + i,
attack: 22 + i,
hasCreditCookie: true
});
pokemon.save(function(err, pokemon) {
if (err) return console.error(err);
console.log('Salvo: ' + pokemon);
});
}
});
Mongoose.connect('mongodb://localhost/be-mean-instagram');
```
**Pokemons novos**
```
Salvo: { created_at: Sun Feb 28 2016 17:32:52 GMT-0300 (Hora oficial do Brasil),
_id: 56d35974f1819cb01c8eae28,
hasCreditCookie: true,
attack: 23,
name: 'Pokemon 1',
__v: 0 }
Salvo: { created_at: Sun Feb 28 2016 17:32:52 GMT-0300 (Hora oficial do Brasil),
_id: 56d35974f1819cb01c8eae29,
hasCreditCookie: true,
attack: 24,
name: 'Pokemon 2',
__v: 0 }
Salvo: { created_at: Sun Feb 28 2016 17:32:52 GMT-0300 (Hora oficial do Brasil),
_id: 56d35974f1819cb01c8eae2a,
hasCreditCookie: true,
attack: 25,
name: 'Pokemon 3',
__v: 0 }
Salvo: { created_at: Sun Feb 28 2016 17:32:52 GMT-0300 (Hora oficial do Brasil),
_id: 56d35974f1819cb01c8eae2b,
hasCreditCookie: true,
attack: 26,
name: 'Pokemon 4',
__v: 0 }
Salvo: { created_at: Sun Feb 28 2016 17:32:52 GMT-0300 (Hora oficial do Brasil),
_id: 56d35974f1819cb01c8eae2c,
hasCreditCookie: true,
attack: 27,
name: 'Pokemon 5',
__v: 0 }
```
**Arquivo de schema**
```JS
const mongoose = require('mongoose');
const Schema = mongoose.Schema;
const _schema = {
pokemons: [{type: Schema.Types.ObjectId, ref: 'pokemons'}]
}
const pokemonSchema = new Schema(_schema);
const data = {
pokemons: ['56d35974f1819cb01c8eae28', '56d35974f1819cb01c8eae29', '56d35974f1819cb01c8eae2a']
};
const Model = mongoose.model('meuspokemons', pokemonSchema);
const poke = new Model(data);
poke.save(function (err, data) {
if (err) return console.log('ERRO: ', err);
console.log('Inseriu: ', data)
})
module.exports = pokemonSchema;
```
**Arquivo app.js**
```JS
require('./config');
const Schema = require('./schema');
```
**Pokemons inseridos**
```
Inseriu: { pokemons:
[ 56d35974f1819cb01c8eae28,
56d35974f1819cb01c8eae29,
56d35974f1819cb01c8eae2a ],
_id: 56d35cd54031a9cc132e50a0,
__v: 0 }
```
2. Crie um Schema de exemplo com validação para os campos (utilizar Arquitetura Atômica, ou seja cada campo sendo um Schema separado):
- email
- cpf
- cnpj
- url
- ip
**Arquivo schema.js**
```JS
const mongoose = require('mongoose');
const Schema = mongoose.Schema;
const email = require( './fields/field-email' );
const cpf = require( './fields/field-cpf' );
const cnpj = require( './fields/fields-cnpj' );
const url = require( './fields/fields-url' );
const ip = require( './fields/fields-ip' );
const _schema = {
email,
cpf,
cnpj,
url,
ip
};
module.exports = new Schema( _schema );
```
**Arquivo field-email**
```JS
const _set = (v) => v.toLowerCase();
const _validate = (v) => /^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/.test(v);
const Field = {
type: String
, set: _set
, validate: [_validate, 'Email ({VALUE}) inválido!']
, required: true
}
module.exports = Field;
```
**Arquivo field-cpf**
```JS
const _validate = (v) => /^(\d{3}\.?\d{3}\.?\d{3}\-?\d{2})$/.test(v);
const Field = {
type: String
, validate: [_validate, 'CPF ({VALUE}) inválido!']
, required: true
}
module.exports = Field;
```
**Arquivo field-cnpj**
```JS
const _validate = (v) => /^(\d{2}\.?\d{3}\.?\d{3}\/?\d{4}-?\d{2})$/.test(v);
const Field = {
type: String
, validate: [_validate, 'CNPJ ({VALUE}) inválido!']
, required: true
}
module.exports = Field;
```
**Arquivo field-url**
```JS
const _validate = (v) => /^((http|https|ftp|ftps):\/\/)?([a-z0-9\-]+\.)?[a-z0-9\-]+\.[a-z0-9]{2,4}(\.[a-z0-9]{2,4})?(\/.*)?$/.test(v);
const Field = {
type: String
, validate: [_validate, 'URL ({VALUE}) inválida!']
, required: true
}
module.exports = Field;
```
**Arquivo field-ip**
```JS
const _validate = (v) => /^(((1[0-9]|[1-9]?)[0-9]|2([0-4][0-9]|5[0-5]))\.){3}((1[0-9]|[1-9]?)[0-9]|2([0-4][0-9]|5[0-5]))$/.test(v);
const Field = {
type: String
, validate: [_validate, 'IP ({VALUE}) inválido!']
, required: true
}
module.exports = Field;
```
3. Dê 3 exemplos diferentes, para cada, utilizando as funções:
- findAndModify
- findOneAndUpdate
- findOneAndRemove
**Schema e model utilizados**
```JS
'use strict';
const mongoose = require('mongoose');
const db = 'mongodb://localhost/be-mean-instagram';
mongoose.connect( db );
const Schema = mongoose.Schema;
const _schema = {
name: { type: String, required: true, match: /^./i },
description: { type: String, required: true, match: /^./i},
type: { type: String, required: true, match: /^./i},
attack: { type: Number, min: 1}
};
const PokemonSchema = new Schema(_schema);
const Model = mongoose.model('pokemons', PokemonSchema);
```
**findAndModify**
```JS
'use strict';
const mongoose = require( 'mongoose' );
const db = 'mongodb://localhost/be-mean-instagram';
mongoose.connect( db );
const Schema = mongoose.Schema;
const _schema = {
name: {type: String, match: /^./i},
description: {type: String, match: /^./i},
type: {type: String, match: /^./i},
attack: {type: Number, min: 1}
};
const PokemonSchema = new Schema(_schema);
PokemonSchema.statics.findAndModify = function (query, sort, doc, options, callback) {
return this.collection.findAndModify(query, sort, doc, options, callback);
};
const Model = mongoose.model('pokemons', PokemonSchema);
const query = { attack: {$lte: 5 } };
const mod = { type: 'eletric' };
const options = { multi: true };
Model.findAndModify(query, [], mod, options, function (err, data) {
if (err) return console.log('Erro: ', err);
return console.log('Alterou: ', data);
});
```
```
Resultado:
$ node findAndModify.js
Alterou: { lastErrorObject: { updatedExisting: true, n: 1 },
value:
{ _id: 56aeb9d04bb106b114749436,
name: 'Pokemon 3',
description: 'pokemon 3',
type: 'eletric',
attack: 51
__v: 0 },
ok: 1 }
```
**findOneAndUpdate**
*Exemplo 1*
```JS
use 'strict';
const query = { name: /pokemon/i};
const mod = { type: 'grass' };
Model.findOneAndUpdate(query, mod, {}, function (err, data) {
if (err) return console.log('Erro: ', err);
return console.log('Alterou: ', data);
})
```
```
Resultado:
Alterou: { __v: 0,
attack: 105,
type: 'teste',
description: 'pokemon 3',
name: 'Pokemon 3',
_id: 56aeb9d04bb106b114749436 }
```
*Exemplo 2*
```JS
'use strict';
const query = { attack: {$lte: 10}};
const mod = {attack: 56};
const options = {multi: true};
Model.findOneAndUpdate(query, mod, options, function (err, data) {
if (err) return console.log('Erro: ', err);
return console.log('Alterou: ', data);
});
```
```
Resultado:
Alterou: { active: false,
attack: 9,
type: 'fire',
description: 'dronzitoo',
name: 'Charmander',
_id: 56a9539b4b828d9c186b53d5 }
```
*Exemplo 3*
```JS
'use strict';
const query = {$and: [{type: 'fire'}, {attack: {$gte: 5}}]};
const mod = {attack: 51, description: 'update attack'};
const options = {multi: true};
Model.findOneAndUpdate(query, mod, options, function (err, data) {
if (err) return console.log('Erro: ', err);
return console.log('Alterou: ', data);
});
```
```
Resultado:
Alterou: { __v: 0,
defense: 888,
attack: 56,
type: 'fire',
description: 'update attack',
name: 'Charmander',
_id: 56a9539b4b828d9c186b53d5 }
```
**findOneAndRemove**
*Exemplo 1*
```JS
'use strict';
const query = { $and: [{type: 'grass'}, {attack: {$gte: 100}}]};
Model.findOneAndRemove(query, function (err, data) {
if (err) return console.log('Erro: ', err);
return console.log('Removeu: ', data);
});
```
```
Resultado:
Removeu: { __v: 0,
attack: 105,
type: 'grass',
description: 'pokemon 3',
name: 'Pokemon 3',
_id: 56aeb9d04bb106b114749436 }
```
*Exemplo 2*
```JS
'use strict';
const query = { attack: null };
Model.findOneAndRemove(query, function (err, data) {
if (err) return console.log('Erro: ', err);
return console.log('Removeu: ', data);
});
```
```
Resultado:
Removeu: { description: 'Fracomon',
defense: null,
attack: null,
name: 'fracote',
_id: 564de099fc7e5880d64a877e }
```
*Exemplo 3*
```JS
'use strict';
const query = {attack: {$lte: 10}};
Model.findOneAndRemove(query, function (err, data) {
if (err) return console.log('Erro: ', err);
return console.log('Removeu: ', data);
});
```
```
Resultado:
Removeu: { active: false,
attack: 56,
type: 'fire',
description: 'update attack',
name: 'Charmander',
_id: 56a9539b4b828d9c186b53d5 }
```
4. Crie 1 Schema com todo CRUD funcional e métodos especiais, que agrupe:
- virtuals
- getters & setters
- method & static
- embedded document
- plugins
- middlewares
**Repositorio:** [Exercicio04](https://github.com/FranciscoValerio/exercicio04-nodejs-aula08)
Devido a esse exercício ter ficado muito grande eu achei melhor criar um repositório para ele.
5. Crie 1 Schema para password com criptografia e arquitetura atômica.
- use SHA256 com SALT como criptografia;
- use middleware com pre save;
- use methods.
**Schema.js**
```JS
'use strict';
const mongoose = require( 'mongoose' );
const Schema = mongoose.Schema;
function passwordHandler(){
const passwordSchema = new Schema({
password: require('./fields/field-password')
});
passwordSchema.methods.criptografa = function () {
const crypto = require('crypto');
const salt = crypto.randomBytes(128).toString('base64');
const key = crypto.pbkdf2Sync( this.password, 'salt', 100000, 256, 'sha256');
return key.toString('hex');
};
passwordSchema.pre('save', true, function( next, done ){
console.log("inserir:", `${this.password}` );
this.password = this.criptografa()
console.log("criptografado:", `${this.password}` );
next();
});
return mongoose.model('Password', passwordSchema);
}
module.exports = exports = passwordHandler();
```
**create-password.js**
```JS
'use strict';
const mongoose = require( 'mongoose' );
const models = require( './index' );
mongoose.connect( 'mongodb://localhost/test' );
let pass = new models.Password();
pass.password = "abc@123";
pass.save();
```
**Resultado:**
```
inserir: abc@123
criptografado: 43efb96f67348450f85afadc9d6c740a3a62f1b9aaa63c08bc6c67f0f5e12f2e44ec2feba91183811df1ede96c53e3e0b2f6f7d19d946f7071e421e5d961e9791896747a4745179c86e59d370b559790e26b1b00a6be22fab2b5cf37da830b6f02586ea63d01105b195717f6de46249463b186ddb8b02f84d9c4aa47ed60a958544795314e0ce7999f58f92d23a2fa46abee6ea77036d223b8cb10dc637e4ad7eba0156ba4b57f9b4a62e0fd26434dec141469ff8b6605cd756a25a0470e30d6c63376e23b77ff18cef80d07ec5605235aea5e35a28c63ff5a3b60e531ab63a198548798e7e9f071a2c3c170dd817b550c1060ca7896ef072f67ae3072ab31b9
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# NodeJS - Aula 05 - Exercício
**Autor**: Igor luíz
**Github**: [Halfeld](https://github.com/Halfeld)
**Data**: 1457856832082
## Instale algum gerenciador de versão do Node.js e instale a versão mais atual como padrão, enquando escrevo é a versão 5.4.0.
#### Instalando `nvm`
```sh
➜ ~ curl https://raw.githubusercontent.com/creationix/nvm/v0.23.2/install.sh | bash
```
#### Instalando versão mais atual do node
```sh
[root@fedora Igor]# nvm install 5.7.1
######################################################################## 100.0%
Checksums empty
Now using node v5.7.1
```
## Inicie um projeto novo para essa aula com `npm` e instale, salvando no package.json.
- 1 Dependência local
```sh
➜ ~ npm install --save commander
```
- 1 Dependência local de desenvolvimento
```sh
➜ ~ npm install --save-dev chai
```
- 1 Dependência local opcional
```sh
➜ ~ npm install --optional chalk
```
## Crie e execute um script, via `npm`, que mostre uma mensagem no console com a global, que possui caminho para o diretório atual.
#### Package.json
```js
{
"name": "npm",
"version": "1.0.0",
"description": "",
"main": "dirname.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1",
"dirname": "node dirname.js"
},
"author": "",
"license": "ISC"
}
```
#### Arquivo dirname.js
```js
console.log(__dirname);
```
#### Saída no console
```sh
(λ.npm.git:(master) ✗) ➜ npm run dirname
> npm@1.0.0 dirname /home/Igor/Documents/Be MEAN/NodeJS/Exercícios/be-mean-instagram-nodejs/exercises/practice/class-5/npm
> node dirname.js
/home/Igor/Documents/Be MEAN/NodeJS/Exercícios/be-mean-instagram-nodejs/exercises/practice/class-5/npm
```
## Cite 5 globais do Node.js e pelo menos 1 exemplo de cada.
#### Atraza a execução da função no tempo escolhido
```js
setTimeout(function() {
console.log('Um teste com setTimeout');
}, 1000);
```
#### Retira o atraza do setTimeout
```js
clearTimeout(myfunction);
```
#### Retorna o diretório atual
```js
console.log(__dirname);
```
#### Chama a função de sempre que passar o tempo definido
```js
setInterval(function() {
console.log('Um teste com setInterval');
}, 1000);
```
#### Retira o intervalo de setInterval
```js
clearInterval(myfunction);
```
## Explique como funciona e de um exemplo de `process`.
É um instancia de EventEmitter, geralmente usamos para capturar eventos disparando callbacks ou não
```js
process.platform // Retorna a plataforma usada 'darwin', 'freebsd', 'linux', 'sunos' ou 'win32'
```
---
---
---
## Criar um arquivo
```js
var fs = require('fs');
fs.writeFile('./content.txt', 'Hello people', 'utf-8', function(err){
if(err) throw err;
console.log('OK');
});
```
## Ler um arquivo
```js
var fs = require('fs');
fs.readFile('./content.txt', 'utf-8', function(err, data){
if(err) throw err;
console.log(data);
});
```
## Editar conteúdo desse arquivo
```js
var fs = require('fs');
fs.readFile('./content.txt', 'utf-8', function(err, data){
if(err) throw err;
console.log('content: ', data); // Hello people
fs.writeFile('./pokemons.txt', 'Hello gays', {encoding: 'utf8', flag: 'a+'}, function(err){
if(err) throw err;
console.log('OK');
});
});
```
## Deletar arquivo
```js
var fs = require('fs');
fs.unlink('./trash.txt', function(err){
if(err) throw err;
console.log('OK');
});
```
## Renomear arquivo
```js
var fs = require('fs');
fs.rename('old.js', 'new.js', function(err){
if(err) throw err;
console.log('OK');
});
```
## Desafio: Criar um servidor web de arquivos estáticos: .css, .html, .js e etc...
#### Codigo
```js
'use strict';
const http = require('http'),
path = require('path'),
fs = require('fs');
const index = fs.readFileSync(path.join(__dirname, 'index.html'));
const server = http.createServer((req, res) => {
let _path = req.url,
_contentType;
if(_path == '/') {
_path = '/index.html';
}
fs.readFile(__dirname + _path, (err, data) => {
if(err) throw err;
switch(path.extname(_path)) {
case '.js':
_contentType = "text/javascript";
break;
case '.css':
_contentType = "text/css";
break;
case '.png':
_contentType = "text/png";
break;
default:
_contentType = "text/html";
}
res.writeHead(200, {"Content-Type": _contentType});
res.end(data);
});
console.log(req.url);
});
server.listen(4000, () => console.log('Servidor no ar!'));
```
#### screen shots
---
---
---
 | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 05 - Exercício
**user:** [hc3](https://github.com/hc3)
**autor:** Eliel das Virgens
**date:** 20/03/2016
#01.Instale algum gerenciador de versão do Node.js e instale a versão mais atual como padrão, enquanto escrevo é a versão 5.4.0
```
hc3@darkSide:~/Bemean/Repositorios/be-mean-instagram-nodejs-exercises/class-05$ nvm ls
v0.11.16
v5.6.0
-> system
stable -> 5.6 (-> v5.6.0) (default)
unstable -> 0.11 (-> v0.11.16) (default)
hc3@darkSide:~/Bemean/Repositorios/be-mean-instagram-nodejs-exercises/class-05$ nvm use 5.6
Now using node v5.6.0
hc3@darkSide:~/Bemean/Repositorios/be-mean-instagram-nodejs-exercises/class-05$ node -v
v5.6.0
```
#02.Inicie um projeto novo para essa aula, com o npm e instale, salvando no package.json
```
hc3@darkSide:~/Bemean/Repositorios/estoqueMEAN$ npm init
This utility will walk you through creating a package.json file.
It only covers the most common items, and tries to guess sane defaults.
See `npm help json` for definitive documentation on these fields
and exactly what they do.
Use `npm install <pkg> --save` afterwards to install a package and
save it as a dependency in the package.json file.
Press ^C at any time to quit.
name: (estoqueMEAN) estoqueMEAN
version: (0.0.0) 0.0.1
description: sistema para controlar estoque e servicos
entry point: (index.js) app.js
test command:
git repository: (https://github.com/hc3/estoqueMEAN.git)
keywords: MEAN , javascript , Webschool
author: hc3
license: (BSD-2-Clause) hc3PL
About to write to /home/hc3/Bemean/Repositorios/estoqueMEAN/package.json:
{
"name": "estoqueMEAN",
"version": "0.0.1",
"description": "sistema para controlar estoque e servicos",
"main": "app.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"repository": {
"type": "git",
"url": "https://github.com/hc3/estoqueMEAN.git"
},
"keywords": [
"MEAN",
"javascript",
"Webschool"
],
"author": "hc3",
"license": "hc3PL",
"bugs": {
"url": "https://github.com/hc3/estoqueMEAN/issues"
}
}
Is this ok? (yes) yes
```
#03.Crie e execute um script, via npm, que mostre uma mensagem no console com a global, que possui caminho para o diretório atual.
lets go make smoke
lgms.js
```
console.log('lets go make smoke!',__dirname);
```
run
```
node lgms.js
lets go make smoke! /home/hc3/Bemean/Repositorios/estoqueMEAN
```
#04.Cite 5 globais do Node.js e pelo menos 1 exemplo de cada.
__dirname mostra o diretório atual
```
console.log(__dirname)
/home/hc3/Bemean/Repositorios/estoqueMEAN
```
setTimeout()
chama um callback após um tempo
```
function shows(){
console.log("HAHAHA");
}
setTimeout(shows, 3000);
node ex4.js
HAHAHA
```
clearTimeout()
utilizada para cronometro
```
function clareando(){
console.log( "HAHAHA 2 SEG STOP");
}
var t = setTimeout(clareando, 5000);
clearTimeout(t);
```
process
```
process.on('exit', (code) => {
console.log('fim processo ', code);
});
fim processo 0
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 05 - Exercício
**user:** [charles7421](https://github.com/charles7421)
**autor:** Charles de Freitas Garcia
## Instale algum gerenciador de versão do Node.js e instale a versão mais atual como padrão, enquanto escrevo é a versão 5.4.0
> npm -v
3.7.3
## Inicie um projeto novo para essa aula, com o `npm` e instale, salvando no `package.json`:
* 1 dependência local
* 1 dependência local de desenvolvimento
* 1 dependência local opcional
> mkdir class05
> cd class05
> npm init
> cat package.json
{
"name": "class05",
"version": "1.0.0",
"description": "Criação do projeto class05, como parte do exercicio do Workshop Be-MEAN",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"keywords": [
"exercicios",
"be-mean",
"webschool",
"nodejs"
],
"author": "Charles de Freitas Garcia",
"license": "MIT"
}
> sudo npm install --save gulp
> sudo npm install --save-dev debug
> sudo npm install --save-optional colors
## Crie e execute um script, via `npm`, que mostre uma mensagem no console com a global, que possui caminho para o diretório atual.
> mkdir global
> cd global
> npm init
* Editei o package.json, adicionando o global.js como script.
´´´js
global.js
'use strict';
console.log(__dirname);
´´´
> cat package.json
{
"name": "global",
"version": "1.0.0",
"description": "Imprime a variavel Global de caminh absoluto da pasta raiz",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1",
"global" : "node global.js"
},
"keywords": [
"teste",
"global",
"pasta"
],
"author": "Charles de Freitas Garcia",
"license": "MIT"
}
> npm run global
/home/charles/be-mean/nodejs/npm/global
## Cite 5 globais do Node.js e pelo menos 1 exemplo de cada.
__dirname
Retorna o diretório atual
console.log(__dirname);
__filename
Retorna o nome do arquivo (caminho absoluto) que iniciou esta execução
console.log(__filename);
clearInterval(t)
Finaliza um timer que foi criado com setInterval().
var interval = setInterval(function(){ timer()}, 1000);
clearInterval(interval);
clearTimeout(t)
Finaliza um timer que foi criado com setTimeOut().
var interval = setTimeOut(function(){ timer()}, 1000);
clearTimeout(interval);
setTimeOut()
Chama uma função ou valida uma expresão depois de um numero especificado de milisegundos.
setTimeout(function(){ alert("Hello"); }, 3000);
## Explique como funciona e de um exemplo de `process`.
Process é utilizado para manipular processos do sistema operacional. Por ser global, não necessita de require. Com ele podemos:
* Matar (Kill) um processo do SO.
* Descobrir o path de execução do Node.
* Saber a memória utilizada pelo Node
* ETC
## Criar um arquivo
'use strict';
var fs = require('fs');
var write = fs.writeFileSync("./teste.txt", "Eu foi criado com FS do Node.js");
## Ler um arquivo
'use strict';
var fs = require('fs');
fs.readFile('./teste.txt', 'utf8', function(err, data){
if (err) throw err;
console.log(data);
});
## Editar conteúdo desse arquivo
'use strict';
var fs = require('fs');
fs.appendFile('./teste.txt', '. Adicionando conteúdo via FS.', 'utf8', function(err, data){
if (err) throw err;
console.log(data);
});
## Deletar arquivo
'use strict';
var fs = require('fs');
fs.unlink('./teste.txt', function(err, data){
if (err) throw err;
console.log("Arquivo deletado");
});
## Renomear o arquivo
'use strict';
var fs = require('fs');
fs.rename('./teste.txt', './teste2.txt', function(err, result){
if (err) throw err;
console.log(result);
});
## Desafio
Continua...
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 05 - Exercício
**user:** [sergiokopplin](https://github.com/sergiokopplin)
**autor:** Sergio Aragao Kopplin
## Instale algum gerenciador de versão do Node.js e instale a versão mais atual como padrão, enquanto escrevo é a versão 5.4.0
```JS
node -v
v5.4.1
npm -v
3.5.3
```
## Inicie um projeto novo para essa aula, com o `npm` e instale, salvando no `package.json`:
```
npm init
This utility will walk you through creating a package.json file.
It only covers the most common items, and tries to guess sensible defaults.
See `npm help json` for definitive documentation on these fields
and exactly what they do.
Use `npm install <pkg> --save` afterwards to install a package and
save it as a dependency in the package.json file.
Press ^C at any time to quit.
name: (be-mean-exercises)
version: (1.0.0)
description:
entry point: (index.js)
test command:
git repository: (https://github.com/sergiokopplin/be-mean-instagram-nodejs-exercises.git)
keywords:
author:
license: (ISC)
About to write to /Users/kopplin/Desktop/be-mean-exercises/package.json:
{
"name": "be-mean-exercises",
"version": "1.0.0",
"description": "- Coloque um email para login( hotmail não funciona ) - Após isso, clique em Webschool para entrar no link do slack - Coloque o email que você digitou antes e crie uma senha - Entre no channel `be-mean-instagram`",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"repository": {
"type": "git",
"url": "git+https://github.com/sergiokopplin/be-mean-instagram-nodejs-exercises.git"
},
"author": "",
"license": "ISC",
"bugs": {
"url": "https://github.com/sergiokopplin/be-mean-instagram-nodejs-exercises/issues"
},
"homepage": "https://github.com/sergiokopplin/be-mean-instagram-nodejs-exercises#readme"
}
Is this ok? (yes)
```
* 1 dependência local
```
npm i lodash --save
be-mean-exercises@1.0.0 /Users/kopplin/Desktop/be-mean-exercises
└── lodash@4.3.0
```
* 1 dependência local de desenvolvimento
```
npm i gulp --save-dev
npm WARN deprecated lodash@1.0.2: lodash@<3.0.0 is no longer maintained. Upgrade to lodash@^4.0.0
be-mean-exercises@1.0.0 /Users/kopplin/Desktop/be-mean-exercises
├─┬ browser-sync@2.11.1
│ ├─┬ chokidar@1.4.1
│ │ └─┬ fsevents@1.0.7
│ │ └─┬ node-pre-gyp@0.6.19
│ │ ├─┬ mkdirp@0.5.1
│ │ │ └── minimist@0.0.8
│ │ ├─┬ npmlog@2.0.0
│ │ │ └─┬ gauge@1.2.2
│ │ │ └─┬ lodash.pad@3.1.1
│ │ │ └── lodash._basetostring@3.0.1
│ │ └─┬ request@2.67.0
│ │ └─┬ har-validator@2.0.3
│ │ └─┬ chalk@1.1.1
│ │ ├── ansi-styles@2.1.0
│ │ ├─┬ has-ansi@2.0.0
│ │ │ └── ansi-regex@2.0.0
│ │ ├── strip-ansi@3.0.0
│ │ └── supports-color@2.0.0
│ └─┬ localtunnel@1.8.1
│ ├─┬ request@2.65.0
│ │ └─┬ har-validator@2.0.6
│ │ └─┬ chalk@1.1.1
│ │ ├── ansi-styles@2.1.0
│ │ ├─┬ has-ansi@2.0.0
│ │ │ └── ansi-regex@2.0.0
│ │ ├── strip-ansi@3.0.0
│ │ └── supports-color@2.0.0
│ └─┬ yargs@3.29.0
│ └─┬ cliui@3.1.0
│ ├─┬ string-width@1.0.1
│ │ └─┬ strip-ansi@3.0.0
│ │ └── ansi-regex@2.0.0
│ └─┬ strip-ansi@3.0.0
│ └── ansi-regex@2.0.0
└─┬ gulp@3.9.1
├── archy@1.0.0
├─┬ chalk@1.1.1
│ ├── ansi-styles@2.1.0
│ ├─┬ has-ansi@2.0.0
│ │ └── ansi-regex@2.0.0
│ ├── strip-ansi@3.0.0
│ └── supports-color@2.0.0
├── deprecated@0.0.1
├─┬ gulp-util@3.0.7
│ ├── array-differ@1.0.0
│ ├── array-uniq@1.0.2
│ ├── beeper@1.1.0
│ ├─┬ chalk@1.1.1
│ │ ├── ansi-styles@2.1.0
│ │ ├─┬ has-ansi@2.0.0
│ │ │ └── ansi-regex@2.0.0
│ │ ├── strip-ansi@3.0.0
│ │ └── supports-color@2.0.0
│ ├── dateformat@1.0.12
│ ├─┬ fancy-log@1.2.0
│ │ ├─┬ chalk@1.1.1
│ │ │ ├── ansi-styles@2.1.0
│ │ │ ├─┬ has-ansi@2.0.0
│ │ │ │ └── ansi-regex@2.0.0
│ │ │ ├── strip-ansi@3.0.0
│ │ │ └── supports-color@2.0.0
│ │ └── time-stamp@1.0.0
│ ├─┬ gulplog@1.0.0
│ │ └── glogg@1.0.0
│ ├─┬ has-gulplog@0.1.0
│ │ └── sparkles@1.0.0
│ ├── lodash._reescape@3.0.0
│ ├── lodash._reevaluate@3.0.0
│ ├── lodash._reinterpolate@3.0.0
│ ├─┬ lodash.template@3.6.2
│ │ ├── lodash._basetostring@3.0.1
│ │ ├── lodash._basevalues@3.0.0
│ │ ├─┬ lodash.escape@3.2.0
│ │ │ └── lodash._root@3.0.0
│ │ └── lodash.templatesettings@3.1.1
│ ├─┬ multipipe@0.1.2
│ │ └─┬ duplexer2@0.0.2
│ │ └── readable-stream@1.1.13
│ ├── replace-ext@0.0.1
│ ├── through2@2.0.1
│ └─┬ vinyl@0.5.3
│ ├── clone@1.0.2
│ └── clone-stats@0.0.1
├── interpret@1.0.0
├─┬ liftoff@2.2.0
│ ├── extend@2.0.1
│ ├─┬ findup-sync@0.3.0
│ │ └── glob@5.0.15
│ ├── flagged-respawn@0.3.1
│ ├── rechoir@0.6.2
│ └── resolve@1.1.7
├─┬ orchestrator@0.3.7
│ ├── end-of-stream@0.1.5
│ ├── sequencify@0.0.7
│ └── stream-consume@0.1.0
├── pretty-hrtime@1.0.1
├── semver@4.3.6
├─┬ tildify@1.1.2
│ └── os-homedir@1.0.1
├─┬ v8flags@2.0.11
│ └── user-home@1.1.1
└─┬ vinyl-fs@0.3.14
├── defaults@1.0.3
├─┬ glob-stream@3.1.18
│ ├── glob@4.5.3
│ ├─┬ glob2base@0.0.12
│ │ └── find-index@0.1.1
│ ├── ordered-read-streams@0.1.0
│ ├─┬ through2@0.6.5
│ │ └── readable-stream@1.0.33
│ └── unique-stream@1.0.0
├─┬ glob-watcher@0.0.6
│ └─┬ gaze@0.5.2
│ └─┬ globule@0.1.0
│ ├─┬ glob@3.1.21
│ │ ├── graceful-fs@1.2.3
│ │ └── inherits@1.0.2
│ ├── lodash@1.0.2
│ └─┬ minimatch@0.2.14
│ ├── lru-cache@2.7.3
│ └── sigmund@1.0.1
├── graceful-fs@3.0.8
├─┬ mkdirp@0.5.1
│ └── minimist@0.0.8
├─┬ strip-bom@1.0.0
│ ├── first-chunk-stream@1.0.0
│ └── is-utf8@0.2.1
├─┬ through2@0.6.5
│ └── readable-stream@1.0.33
└─┬ vinyl@0.4.6
└── clone@0.2.0
```
* 1 dependência local opcional
```
npm i -O mongoose
be-mean-exercises@1.0.0 /Users/kopplin/Desktop/be-mean-exercises
├─┬ browser-sync@2.11.1
│ └─┬ chokidar@1.4.1
│ └─┬ fsevents@1.0.7
│ └─┬ node-pre-gyp@0.6.19
│ └── semver@5.1.0
└─┬ mongoose@4.4.3
├── bson@0.4.21
├── hooks-fixed@1.1.0
├── kareem@1.0.1
├─┬ mongodb@2.1.6
│ ├── es6-promise@3.0.2
│ ├─┬ mongodb-core@1.3.1
│ │ └─┬ require_optional@1.0.0
│ │ ├── resolve-from@2.0.0
│ │ └── semver@5.1.0
│ └── readable-stream@1.0.31
├── mpath@0.2.1
├── mpromise@0.5.5
├─┬ mquery@1.6.3
│ ├── bluebird@2.9.26
│ └── sliced@0.0.5
├── muri@1.1.0
├── regexp-clone@0.0.1
└── sliced@1.0.1
```
```
{
"name": "be-mean-exercises",
"version": "1.0.0",
"description": "- Coloque um email para login( hotmail não funciona ) - Após isso, clique em Webschool para entrar no link do slack - Coloque o email que você digitou antes e crie uma senha - Entre no channel `be-mean-instagram`",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"repository": {
"type": "git",
"url": "git+https://github.com/sergiokopplin/be-mean-instagram-nodejs-exercises.git"
},
"author": "",
"license": "ISC",
"bugs": {
"url": "https://github.com/sergiokopplin/be-mean-instagram-nodejs-exercises/issues"
},
"homepage": "https://github.com/sergiokopplin/be-mean-instagram-nodejs-exercises#readme",
"dependencies": {
"lodash": "^4.3.0"
},
"devDependencies": {
"gulp": "^3.9.1"
},
"optionalDependencies": {
"mongoose": "^4.4.3"
}
}
```
## Crie e execute um script, via `npm`, que mostre uma mensagem no console com a global, que possui caminho para o diretório atual.
```
{
"name": "be-mean-exercises",
"version": "1.0.0",
"description": "- Coloque um email para login( hotmail não funciona ) - Após isso, clique em Webschool para entrar no link do slack - Coloque o email que você digitou antes e crie uma senha - Entre no channel `be-mean-instagram`",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1",
"pr": "node teste.js"
},
"repository": {
"type": "git",
"url": "git+https://github.com/sergiokopplin/be-mean-instagram-nodejs-exercises.git"
},
"author": "",
"license": "ISC",
"bugs": {
"url": "https://github.com/sergiokopplin/be-mean-instagram-nodejs-exercises/issues"
},
"homepage": "https://github.com/sergiokopplin/be-mean-instagram-nodejs-exercises#readme",
"dependencies": {
"lodash": "^4.3.0"
},
"devDependencies": {
"gulp": "^3.9.1"
},
"optionalDependencies": {
"mongoose": "^4.4.3"
}
}
```
```teste.js
console.log(__dirname);
```
```
npm run pr
> be-mean-exercises@1.0.0 pr /Users/kopplin/Desktop/be-mean-exercises
> node teste.js
/Users/kopplin/Desktop/be-mean-exercises
```
## Cite 5 globais do Node.js e pelo menos 1 exemplo de cada.
```JS
__dirname
console.log(__dirname);
__filename
console.log(__filename);
Buffer
var buff = new Buffer('Hello World!');
console.log(buff.toString());
setTimeout
setTimeout(function(){
console.log("esse vem com atraso de 1s");
}, 1000);
setInterval
setInterval(() => console.log("intervalo de 1s"), 1000);
```
## Explique como funciona e de um exemplo de `process`.
O process é uma instância do EventEmitter, portanto emite eventos.
```JS
process.on('uncaughtException', (err) => {
console.log(`Caught exception: ${err}`);
});
```
---
Aula 05 - Parte 2
## Criar um arquivo
```JS
var fs = require('fs');
fs.writeFile('teste.txt', 'Esse é o conteúdo do arquivo', function (err){
if(err) throw err;
console.log('Arquivo salvo');
});
```
```
$ cat teste.txt
Esse é o conteúdo do arquivo%
```
## Ler um arquivo
```JS
var fs = require('fs');
fs.readFile('teste.txt', 'utf8' ,function (err, data){
if(err) throw err;
console.log(data);
});
```
```
node read-file.js
Esse é o conteúdo do arquivo
```
## Editar conteúdo desse arquivo
```JS
var fs = require('fs');
var texto = "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.";
fs.writeFile('teste.txt', texto ,function (err, data){
if(err) throw err;
console.log('Arquivo alterado!');
});
```
```
node edit-file.js
Arquivo alterado!
```
## Deletar arquivo
```JS
var fs = require('fs');
fs.unlink('teste.txt', function (err){
if(err) throw err;
console.log('Arquivo deletado');
});
```
```
node delete-file.js
Arquivo deletado
```
## Renomear o arquivo
```JS
var fs = require('fs');
fs.rename('teste.txt', 'novo-nome.txt', function (err){
if(err) throw err;
console.log('Arquivo alterado');
});
```
```
node rename-file.js
Arquivo alterado
```
##Desafio: Criar um servidor web de arquivos estáticos: .css, .html, .js e etc...
```JS
var http = require('http')
, fs = require('fs');
http.createServer(function(request, response){
var contentType;
switch (request.url) {
case '/index.html':
contentType = 'text/html';
break;
case '/style.css':
contentType = 'text/css';
break;
case '/server.js':
contentType = 'text/javascript';
break;
default:
response.writeHead(200, {'Content-Type': 'text/html; charset=utf-8'});
response.write('<h1>404 - O arquivo não existe</h1>');
break;
}
fs.readFile(request.url.substring(1), 'utf8', function (err, data){
if (err) {
console.log(err);
return false;
}
response.writeHead(200, { 'Content-Type': contentType });
response.end(data);
});
}).listen(3000, function(){
console.log('Servidor rodando em localhost:3000');
});
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 05 - Exercício
**user:** [filipe1309](https://github.com/filipe1309)
**autor:** Filipe Leuch Bonfim
## Instale algum gerenciador de versão do Node.js e instale a versão mais atual como padrão, enquanto escrevo é a versão 5.4.0
#### NVM
```
sudo npm install -g nvm
nvm install 5.4.0
nvm use 5.4.0
nvm alias default 5.4.0
```
## Inicie um projeto novo para essa aula, com o `npm` e instale, salvando no `package.json`:
```
npm init
This utility will walk you through creating a package.json file.
It only covers the most common items, and tries to guess sensible defaults.
See `npm help json` for definitive documentation on these fields
and exactly what they do.
Use `npm install <pkg> --save` afterwards to install a package and
save it as a dependency in the package.json file.
Press ^C at any time to quit.
name: (projeto_ex2)
version: (1.0.0) 0.0.1
description: Projeto criado para o exercicio 2 da aula 5 de Node.js
entry point: (index.js)
test command:
git repository:
keywords: nodejs, bemean, webschool
author: Filipe Leuch Bonfim
license: (ISC)
About to write to /home/filipe1309/devel/be_mean/be-mean-modulo-nodejs/src/class05/projeto_ex2/package.json:
```
```js
{
"name": "projeto_ex2",
"version": "0.0.1",
"description": "Projeto criado para o exercicio 2 da aula 5 de Node.js",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"keywords": [
"nodejs",
"bemean",
"webschool"
],
"author": "Filipe Leuch Bonfim",
"license": "ISC"
}
```
#### 1 dependência local
##### Comando
```
npm i --save bower
```
##### package.json
```js
"dependencies": {
"bower": "^1.7.7"
},
```
#### 1 dependência local de desenvolvimento
##### Comando
```
npm i --save-dev socket.io
```
##### package.json
```js
"devDependencies": {
"socket.io": "^1.4.5"
},
```
#### 1 dependência local opcional
##### Comando
```
npm i --save-optional mocha
```
##### package.json
```js
"optionalDependencies": {
"mocha": "^2.4.5"
}
```
## Crie e execute um script, via `npm`, que mostre uma mensagem no console com a global, que possui caminho para o diretório atual.
#### script_npm_run_ex03.js
```js
console.log(__dirname);
```
#### package.json
```js
// ...
"scripts": {
"path_dir_atual": "node script_npm_run_ex03.js"
},
// ...
```
#### Terminal
```
npm run path_dir_atual
> projeto_ex2@0.0.1 path_dir_atual /home/filipe1309/devel/be_mean/be-mean-modulo-nodejs/src/class05/projeto_ex2
> node script_npm_run_ex03.js
/home/filipe1309/devel/be_mean/be-mean-modulo-nodejs/src/class05/projeto_ex2
```
## Cite 5 globais do Node.js e pelo menos 1 exemplo de cada.
#### console
```js
console.log('hello world');
```
#### process
```js
// Arquitetura do sistema
console.log('This processor architecture is ' + process.arch);
```
#### setInterval(cb, ms)
```js
// a cada 1 segundo retorna "My Interval"
setInterval(() => console.log("My Interval"), 1000);
```
#### setTimeout(cb, ms)
```js
var myTimeOut = setTimeout(() => {
console.log('My TimeOut');
}, 6000);
// Após 6 segundos retorna "My TimeOut"
myTimeOut
```
#### clearTimeout(t)
```js
var myTimeOut = setTimeout(() => {
console.log('My TimeOut');
}, 6000);
clearTimeout(myTimeOut);
// não retorna nada
myTimeOut
```
## Explique como funciona e de um exemplo de `process`.
O `process` é um objeto global e uma instancia de `EventEmitter`, que contém diversas funções e propriedades sobre o processo que está rodando o Node.js
Exemplo
```js
// Utilização de memória do Node.js em bytes
console.log(process.memoryUsage());
// Saída
{ rss: 22884352, heapTotal: 7523616, heapUsed: 4001696 }
```
## Criar um arquivo
```js
'use strict';
const fs = require('fs');
fs.writeFile("arquivo.txt", "Hello World!!!", 'utf-8', function(err, result) {
if(err) throw err;
console.log('==> Arquivo criado!!!');
});
// Saída
//==> Arquivo criado!!!
```
## Ler um arquivo
```js
'use strict';
const fs = require('fs');
fs.readFile("arquivo.txt", 'utf-8', function(err, result) {
if(err) throw err;
console.log('==> Arquivo lido: ', result);
});
// Saída
//==> Arquivo lido: Hello World!!!
```
## Editar conteúdo desse arquivo
```js
'use strict';
const fs = require('fs');
fs.readFile("arquivo.txt", 'utf-8', function(err, result){
if (err) throw err;
var conteudo_editado = result + " - Editado!!!";
fs.writeFile("arquivo.txt" ,conteudo_editado, "utf-8", function (err) {
if (err) throw err;
console.log("==> Arquivo editado!!!");
});
});
// Saída
// ==> Arquivo editado!!!
```
## Deletar arquivo
```js
'use strict';
const fs = require('fs');
fs.unlink("arquivo_renomeado.txt", function(err){
if (err) throw err;
console.log("==> Arquivo removido!!!");
});
// Saída
// ==> Arquivo removido!!!
```
## Renomear o arquivo
```js
'use strict';
const fs = require('fs');
fs.rename("arquivo.txt", "arquivo_renomeado.txt", function(err){
if(err) throw err;
console.log("==> Arquivo renomeado!!!");
})
// Saída
// ==> Arquivo renomeado!!!
```
## Desafio
Criar um servidor web de arquivos estáticos: .css, .html, .js e etc... UTILIZANDO SOMENTE fs E http
```js
'use strict';
const http = require('http')
, fs = require('fs')
;
http.createServer(function(req, res){
var responseStatusCode = 200
, file_req = req.url
, ext = file_req.split(".").pop().toLowerCase()
, cType = 'text/html;charset=utf8'
, dir
;
// Redireciona para index, caso não seja informada nenhma rota
if (file_req === '/') {
ext = 'html';
file_req += 'index.' + ext;
}
/*
A priori, os arquivos estão em pastas com o nome das extensões,
a não ser no caso de imagens que está na pasta img.
*/
dir = ext;
// Define o mimetype adequado para o arquivo solicitado
switch (ext) {
case 'html':
break;
case 'css':
cType = 'text/css';
break;
case 'js':
cType = 'text/javascript';
break;
case 'jpeg':
case 'jpg':
cType = 'image/jpeg';
dir = 'img';
break;
case 'png':
cType = 'image/png';
dir = 'img';
break;
case 'gif':
cType = 'image/gif';
dir = 'img';
break;
default:
responseStatusCode = 404;
break;
}
// Define o cabeçalho de resposta
res.writeHead(responseStatusCode, {'Content-Type': cType});
// Ajusta o path, incluido a pasta do arquivo requisitado
var path_file_req = dir+file_req;
try{
/*
Caso um diretório de arquivos (css, html, js, img) seja informado,
caso exista, os arquivos daquele diretório serão listados
*/
if (ext.substring(0, 1) == '/') {
dir = ext.substring(1);
fs.accessSync( dir, fs.R_OK );
if( fs.lstatSync(dir).isDirectory() ){
var dir_files = fs.readdirSync(dir);
dir_files.forEach(dir_file => {
res.write('<a href="' + dir_file + '">' + dir_file + '</a><br>' );
});
}
} else {
/*
Caso um arquivo (css, html, js, jpg, jpeg) seja informado,
caso exista, o mesmo é exibido diretamente na página
*/
// Verifica se o arquivo existe
fs.accessSync( path_file_req, fs.R_OK );
// le o arquivo
var file_server = fs.readFileSync(path_file_req);
// Escreve o conteudo do arquivo no response
res.write(file_server);
}
} catch(e){
var file_error = fs.readFileSync('html/not_found.html');
res.write(file_error);
}
console.log("file: ", file_req);
console.log("ext: ", ext);
console.log("cType: ", cType);
// Envia response
res.end();
}).listen(3000, function(){
console.log('Servidor rodando em localhost:3000');
});
```
#### [index] `localhost:3000/`
#### [Arquivo] `localhost:3000/main.css`
#### [404] `localhost:3000/non_ecziste`
#### [Diretório] `localhost:3000/css`
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 05 - Exercício
**User:** [daniofilho](https://github.com/daniofilho)
**Autor:** Dânio Filho
**Date:** 1453236237757
# Exercício npm
**1.** Instale algum gerenciador de versão do Node.js e instale a versão mais atual como padrão, enquanto escrevo é a versão 5.4.
~~~ terminal
> npm -v
3.3.12
> node -v
v5.4.0
~~~
**2.** Inicie um projeto novo para esse exercício, com o **npm** e instale, salvando no **package.json**:
- 1 dependência local
- 1 dependência local de desenvolvimento
- 1 dependência local opcional
~~~ json
{
"name": "daniofilho-node-exercicio-05",
"version": "1.0.0",
"description": "Exercício Node - Aula 05",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1",
"ex03": "node script.js"
},
"keywords": [
"node",
"exercicio",
"webschool"
],
"author": "Dânio Filho",
"license": "ISC",
"dependencies": {
"mongoose": "^4.3.6"
},
"devDependencies": {
"jasmine": "^2.4.1"
},
"optionalDependencies": {
"colors": "^1.1.2"
}
}
~~~
**3.** Crie e execute um script, via **npm**, que mostre uma mensagem no console com global, que possui caminho para o diretório atual.
~~~ js
//script.js
console.log(__dirname);
~~~
`npm run ex03`
~~~ js
//retorno
> daniofilho-node-exercicio-05@1.0.0 ex03 /Users/daniofilho/Dropbox/Estudo/Be MEAN/02 - NodeJS/aula-05/exercicio
> node script.js
/Users/daniofilho/Dropbox/Estudo/Be MEAN/02 - NodeJS/aula-05/exercicio
~~~
**4.** Cite 5 globais do Node.js e pelo menos 1 exemplo de cada.
**console**
Usado para printar mensagens no terminal.
~~~ js
console.log( 'Usando o Global console.' );
~~~
**require**
Usado para chamar módulos do Node.
~~~ js
require('http');
~~~
**setInterval**
Usado para executar uma função a cada "x" milisegundos.
~~~ js
setInterval(() => {
console.log(Date.now());
}, 1000);
~~~
**__dirname**
Retorna o caminho do diretório atual.
~~~ js
console.log(__dirname);
~~~
**__filename**
Retorna o caminho do arquivo atual.
~~~ js
console.log(__filename);
~~~
**5.** Explique como funciona e dê um exemplo de *process*
**process** é um módulo global do Node que transmite eventos, ou seja, toda vez que queremos executar qualquer ação quando um evento ocorrer, usamos o process.
Um exemplo é mostrar uma mensagem para o usuário ao finalizar uma sessão no terminal:
~~~ js
'use strict'
//código...
process.on('SIGINIT', () => {
console.log('saindo...');//mostra a mensagem antes de sair
process.exit(0);//finaliza o processo
});
~~~
# Exercício FileSystem
- Criar um arquivo
- Ler um arquivo
- Editar o conteúdo desse arquivo
- renomear arquivo
- deletar arquivo
~~~ js
'use strict'
var fs = require('fs');
let now = Date.now();
let fileTxt = './' + now + '.txt';
console.log('#debug: Date.now() => ', now);
//Cria o arquivo
fs.writeFile(fileTxt, 'Date.now(): ' + now , (err) => {
if (err) throw err;
console.log('Arquivo criado');
},()=> {
//Lê
fs.readFile(fileTxt, 'utf8', (err, data) => {
if(err) throw err;
},()=> {
//Edita o conteúdo
fs.readFile(fileTxt, 'utf-8', (err, data) => {
if (err) throw err;
var alterado = data + "\nNovo conteúdo.";
fs.writeFile(fileTxt, alterado, 'utf-8', function (err) {
if (err) throw err;
},()=> {
//Renomeia o arquivo
fs.rename(fileTxt,'./fuirenomeado.txt', (err, data) => {
if(err) throw err;
},()=> {
//Deleta o arquivo
fs.unlink('./fuirenomeado.txt', (err) => {
if(err) throw err;
});//unlink
});//rename
});//writeFile
});//readFile
});//readFile
});//writeFile
~~~
# desafio: criar um servidor web de arquivos estáticos: .css, .html, .js e etc...
**Arquivos usados no exercício foram gerados via [Initializr](http://www.initializr.com)**
**Servidor Node**
~~~ js
var http = require("http");
var fs = require("fs");
var path = require("path");
http.createServer(function(request, response){
//Dependendo do tipo de arquivo, retorna um content type diferente
var filePath = "/site" + request.url;
if (filePath == '/site/')
filePath = '/site/index.html';
filePath = __dirname + filePath;
var extname = path.extname(filePath);
var contentType = 'text/html';
//Debug
console.log( "url: ", request.url );
console.log( "arquivo: ", filePath );
console.log( " - - - - - ");
//Verifica os tipos de arquivo
switch ( extname.toLowerCase() ) {
case '.js':
contentType = 'text/javascript';
break;
case '.css':
contentType = 'text/css';
break;
case '.jpg':
case '.jpeg':
contentType = 'image/jpeg';
break;
case '.png':
contentType = 'image/png';
break;
case '.gif':
contentType = 'image/gif';
break;
}
//Retorna o arquivo
fs.readFile(filePath, function(err, content) {
if (err) {
response.writeHead(500);
response.end();
} else {
response.writeHead(200, { 'Content-Type': contentType });
response.end(content, 'utf-8');
}
});
}).listen(3000, function(){
console.log('Servidor rodando em localhost:3000');
});
~~~
**Print do navegador **
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 05 - Exercício
**user:** [Geriel Castro](https://github.com/geriel)
**autor:** Geriel Castro
## Instale algum gerenciador de versão do Node.js e instale a versão mais atual como padrão, enquanto escrevo é a versão 5.4.0
Baixei o [NVM](https://github.com/creationix/nvm) , peguei a referencia desse site desconhecido aqui [NomaDev](http://nomadev.com.br/node-js-o-que-%C3%A9-nvm-e-como-gerenciar-vers%C3%B5es-do-node/)
```js
node -v v5.8.0
```
## Inicie um projeto novo para essa aula, com o `npm` e instale, salvando no `package.json`:
```js
npm init
This utility will walk you through creating a package.json file.
It only covers the most common items, and tries to guess sensible defaults.
See `npm help json` for definitive documentation on these fields
and exactly what they do.
Use `npm install <pkg> --save` afterwards to install a package and
save it as a dependency in the package.json file.
Press ^C at any time to quit.
name: (new-project)
version: (1.0.0)
description: Novo Projeto usando npm init aula5 exercicio
entry point: (index.js)
test command:
git repository:
keywords: mongodb, nodejs
author: Geriel Castro
license: (ISC)
About to write to /Applications/XAMPP/xamppfiles/htdocs/estudo/estudos/workshop-be-mean/nodejs/aula5/new-project/package.json:
{
"name": "new-project",
"version": "1.0.0",
"description": "Novo Projeto usando npm init aula5 exercicio",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"keywords": [
"mongodb",
"nodejs"
],
"author": "Geriel Castro",
"license": "ISC"
}
```
* 1 dependência local:
`npm i --save socket.io`
* 1 dependência local de desenvolvimento:
`npm i --save--dev grunt`
* 1 dependência local opcional:
`npm i colors --save-optional`
**Arquivo package.json atualizado**
```js
{
"name": "new-project",
"version": "1.0.0",
"description": "Novo Projeto usando npm init aula5 exercicio",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"keywords": [
"mongodb",
"nodejs"
],
"author": "Geriel Castro",
"license": "ISC",
"dependencies": {
"socket.io": "^1.4.5"
},
"devDependencies": {
"grunt": "^1.0.1"
},
"optionalDependencies": {
"colors": "^1.1.2"
}
}
```
## Crie e execute um script, via `npm`, que mostre uma mensagem no console com a global, que possui caminho para o diretório atual.
**app.js**
```js
console.log('Diretorio: ', __dirname);
```
**package.json**
```js
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1",
"getdir": "node app.js"
}
```
**npm run**
```js
npm run getdir
> new-project@1.0.0 getdir /Applications/XAMPP/xamppfiles/htdocs/estudo/estudos/workshop-be-mean/nodejs/aula5/new-project
> node app.js
Diretorio: /Applications/XAMPP/xamppfiles/htdocs/estudo/estudos/workshop-be-mean/nodejs/aula5/new-project
```
## Cite 5 globais do Node.js e pelo menos 1 exemplo de cada.
1. `__dirname` retorna o diretório que o script está sendo executado.
```js
console.log(__dirname);
```
## Explique como funciona e de um exemplo de `process`.
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 05 - Exercício
**user:** [carloshenriqueribeiro](https://github.com/carloshenriqueribeiro)
**autor:** Carlos Henrique Ribeiro
## Instale algum gerenciador de versão do Node.js e instale a versão mais atual como padrão, enquanto escrevo é a versão 5.4.0
> npm -v
4.1.2
## Inicie um projeto novo para essa aula, com o `npm` e instale, salvando no `package.json`:
* 1 dependência local
* 1 dependência local de desenvolvimento
* 1 dependência local opcional
´´´
> mkdir newproject
> cd newproject
> npm init
> cat package.json
{
"name": "loveproject",
"version": "1.0.1",
"description": "love project transmit love!",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"author": "Carlos Henrique Ribeiro\u001b[1;6D\u001b[1;6D\u001b[1;6D\u001b[1;6D\u001b[1;6D\u001b[1;6D\u001b[C\u001b[C\u001b[C\u001b[C\u001b[C\u001b[itos",
"license": "ISC"
}
´´´
´´´
> npm i -S bower
> npm i -S -D broserify
> npm i -S -O grunt-cli
´´´
## Crie e execute um script, via `npm`, que mostre uma mensagem no console com a global, que possui caminho para o diretório atual.
> mkdir global
> cd global
> npm init
* Editei o package.json, adicionando o global.js como script.
´´´js
global.js
'use strict';
console.log(__dirname);
´´´
> cat package.json
{
"name": "global",
"version": "1.0.0",
"description": "Imprime a variavel Global de caminh absoluto da pasta raiz",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1",
"global" : "node global.js"
},
"keywords": [
"global",
"webschool"
],
"author": "Carlos Henrique Ribeiro",
"license": "MIT"
}
> npm run global
/users/chori/be-mean/nodejs/npm/global
## Cite 5 globais do Node.js e pelo menos 1 exemplo de cada.
__dirname
Retorna o diretório atual
console.log(__dirname);
__filename
Retorna o nome do arquivo (caminho absoluto) que iniciou esta execução
console.log(__filename);
clearInterval(t)
Finaliza um timer que foi criado com setInterval().
var interval = setInterval(function(){ timer()}, 1000);
clearInterval(interval);
clearTimeout(t)
Finaliza um timer que foi criado com setTimeOut().
var interval = setTimeOut(function(){ timer()}, 1000);
clearTimeout(interval);
setTimeOut()
Chama uma função ou valida uma expresão depois de um numero especificado de milisegundos.
setTimeout(function(){ alert("Hello"); }, 3000);
## Explique como funciona e de um exemplo de `process`.
Process é utilizado para manipular processos do sistema operacional. Por ser global, não necessita de require. Com ele podemos:
* Matar (Kill) um processo do SO.
* Descobrir o path de execução do Node.
* Saber a memória utilizada pelo Node
* ETC
## Criar um arquivo
'use strict';
var fs = require('fs');
var write = fs.writeFileSync("./teste.txt", "Eu foi criado com FS do Node.js");
## Ler um arquivo
'use strict';
var fs = require('fs');
fs.readFile('./teste.txt', 'utf8', function(err, data){
if (err) throw err;
console.log(data);
});
## Editar conteúdo desse arquivo
'use strict';
var fs = require('fs');
fs.appendFile('./teste.txt', '. Adicionando conteúdo via FS.', 'utf8', function(err, data){
if (err) throw err;
console.log(data);
});
## Deletar arquivo
'use strict';
var fs = require('fs');
fs.unlink('./teste.txt', function(err, data){
if (err) throw err;
console.log("Arquivo deletado");
});
## Renomear o arquivo
'use strict';
var fs = require('fs');
fs.rename('./teste.txt', './teste2.txt', function(err, result){
if (err) throw err;
console.log(result);
});
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 05 - Exercício
**user:** [Pauloxt1](https://github.com/Pauloxt1)<br>
**autor:** Paulo Roberto
## Instale algum gerenciador de versão do Node.js e instale a versão mais atual como padrão, enquanto escrevo é a versão 5.4.0
```shell
paulo@Paulo:~/workshop-be-mean/nodejs/mongoose$ sudo npm install -g n
/usr/local/bin/n -> /usr/local/lib/node_modules/n/bin/n
/usr/local/lib
└── n@2.1.0
```
```shell
paulo@Paulo:~/workshop-be-mean/nodejs/mongoose$ n
ο node/5.4.1
```
## Inicie um projeto novo para essa aula, com o `npm` e instale, salvando no `package.json`:
```shell
paulo@Paulo:~/workshop-be-mean/nodejs/aula5/exerc$ npm init
About to write to /home/paulo/workshop-be-mean/nodejs/aula5/exerc/package.json:
{
"name": "exercicio5",
"version": "1.0.0",
"description": "Exercicio da aula 5",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"keywords": [
"webschool",
"exercicio",
"aula5"
],
"author": "Paulo Roberto",
"license": "MIT"
}
```
- 1 dependência local
```shell
paulo@Paulo:~/workshop-be-mean/nodejs/aula5/exerc$ npm i -S mongoose
```
- 1 dependência local de desenvolvimento
```shell
paulo@Paulo:~/workshop-be-mean/nodejs/aula5/exerc$ npm install -SD n
```
- 1 dependência local opcional
```shell
npm install -SO color
```
## Crie e execute um script, via `npm`, que mostre uma mensagem no console com a global, que possui caminho para o diretório atual.
```js
// filename: show_directory.js
console.log(__dirname);
```
```js
// package.json
"scripts":{
"ondeuto": "node show_directory.js"
}
```
```shell
paulo@Paulo:~/workshop-be-mean/nodejs/aula5/exerc$ npm run ondeuto
> exercicio5@1.0.0 ondeuto /home/paulo/workshop-be-mean/nodejs/aula5/exerc
> node show_directory.js
/home/paulo/workshop-be-mean/nodejs/aula5/exerc
```
## Cite 5 globais do Node.js e pelo menos 1 exemplo de cada.
```js
console.log(__dirname);
```
```js
console.log(__filename);
```
```js
'use strict';
var interval = setInterval(()=>{
console.log('Batata');
}, 2000);
```
```js
clearInterval(interval);
```
```js
setTimeout(()=>{
console.log('zeus');
}, 1000);
```
## Explique como funciona e de um exemplo de `process`.
É um objeto global que manipula eventos.
```js
// filename: process.js
'use strict';
process.on('uncaughtException', (err) => {
console.log('Ocorreu um erro desconhecido');
});
naoExisteFunc();
```
```shell
paulo@Paulo:~/workshop-be-mean/nodejs/aula5/exerc$ node process.js
Ocorreu um erro desconhecido
```
## File System
### Criar um arquivo.
```js
// file: createFile
const fs = require('fs');
fs.writeFile('./novoArquivo.txt', '', function(err, result){
if(err) throw err;
console.log(result);
});
```
```js
paulo@Paulo:~/workshop-be-mean/nodejs/4$ node createFile.js
undefined
```
### Ler um arquivo.
```js
// file: readFile.js
const fs = require('fs');
fs.readFile('./novoArquivo.txt', 'utf-8', function(err, data){
console.log(data);
});
```
```js
paulo@Paulo:~/workshop-be-mean/nodejs/4$ node readFile.js
```
### Editar conteúdo desse arquivo.
```js
// file: updateFile.js
const fs = require('fs');
fs.writeFile('./novoArquivo.txt', 'Update file', function(err, result){
if(err) throw err;
console.log(result);
});
```
```js
paulo@Paulo:~/workshop-be-mean/nodejs/4$ node updateFile.js
undefined
```
### Deletar arquivo.
```js
// file: deleteFile.js
const fs = require('fs');
fs.unlink('renameFile.txt', function(err){
if(err) throw err;
console.log('Deletado com sucesso');
});
```
```js
paulo@Paulo:~/workshop-be-mean/nodejs/4$ node deleteFile.js
Deletado com sucesso
```
### Renomear o arquivo.
```js
// file: renameFile.js
const fs = require('fs');
fs.rename('./novoArquivo.txt', 'renameFile.txt', function(err, result){
if(err) throw err;
console.log(result);
});
```
```js
paulo@Paulo:~/workshop-be-mean/nodejs/4$ node renameFile.js
undefined
```
## Desafio: Criar um servidor web de arquivos estáticos.
```js
'use strict';
const http = require('http'),
fs = require('fs'),
port = 3000;
// create directory for files.
try{
fs.accessSync('files', fs.F_OK);
}catch (e){
fs.mkdirSync('files');
}
http.createServer(function(req, res){
var path = 'files'+req.url;
try{
fs.accessSync(path, fs.R_OK);
if(fs.lstatSync(path).isDirectory()){
res.writeHeader(200, {"Content-Type": "text/html;charset=utf-8"});
try{
var indexPath = path+'/index.html';
res.write(fs.readFileSync(indexPath, 'utf-8'));
}catch(e){
var files = fs.readdirSync(path);
files.forEach(nome =>{
res.write('<a href="'+req.url+'/'+nome+'">'+nome+'</a><br>');
});
}
}else{
var typeFile = path.split(".");
switch(typeFile[typeFile.length-1]){
case 'css':
res.writeHeader(200, {"Content-Type": "text/css"});
break;
case 'html':
res.writeHeader(200, {"Content-Type": "text/html;charset=utf-8"});
break;
case 'jpg':
res.writeHeader(200, {"Content-Type": "image/jpeg"});
break;
case 'png':
res.writeHeader(200, {"Content-Type": "image/png"});
break;
case 'gif':
res.writeHeader(200, {"Content-Type": "image/gif"});
break;
}
res.write(fs.readFileSync(path));
}
} catch(e){
res.writeHeader(404, {"Content-Type": "text/html;charset=utf-8"});
res.write('Página não encontrada');
}
res.end();
}).listen(port, () => {
console.log('Servidor levantado na porta '+port);
});
```
<b>Acessando servidor levantado:</b>
<br>
<b>Acessando diretório:</b>
<br>
<b>Acessando local inexistente:</b>
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 05 - Exercício
**user:** [felipelopesrita](https://github.com/felipelopesrita)
**autor:** Felipe José Lopes Rita
## Instale algum gerenciador de versão do Node.js e instale a versão mais atual como padrão, enquanto escrevo é a versão 5.4.0
O gerenciado instalado foi o *n*
```js
➡ sudo n -V
2.1.0
➡ node -v
v5.6.0
```
## Inicie um projeto novo para essa aula, com o `npm` e instale, salvando no `package.json`:
```js
npm init
npm i --save mongoose
npm i --save-dev jasmine
npm i --optional colors
cat package.json
{
"name": "ex05",
"version": "1.0.0",
"description": "Exercício 05",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"author": "Felipe",
"license": "ISC",
"dependencies": {
"mongoose": "^4.4.5"
},
"devDependencies": {
"jasmine": "^2.4.1"
},
"optionalDependencies": {
"color": "^0.11.1",
"colors": "^1.1.2"
}
}
```
## Crie e execute um script, via `npm`, que mostre uma mensagem no console com a global, que possui caminho para o diretório atual.
```js
➡ npm start
> ex05@1.0.0 start /home/felipe/Documentos/myRepo/Workshop-be-mean/nodejs/exercises/ex05
> node script.js
/home/felipe/Documentos/myRepo/Workshop-be-mean/nodejs/exercises/ex05
```
## Cite 5 globais do Node.js e pelo menos 1 exemplo de cada.
*console*
```js
//Usado para exibir mensagens no console
console.log('JS é vida');
//Saída: JS é vida
```
*filename*
```js
console.log(__filename);
//Saída: /home/felipe/Documentos/myRepo/Workshop-be-mean/nodejs/exercises/ex05/script.js
```
*process*
```js
process.on('exit', (code) => {
console.log('O processo terminou com o código: ', code);
//Saída: O processo terminou com o código: 0
});
```
*dirname*
```js
console.log(__dirname);
//Saída: /home/felipe/Documentos/myRepo/Workshop-be-mean/nodejs/exercises/ex05
```
*setTimeOut*
```js
setTimeOut(()=>{
console.log('Esse texto só será exibido depois de 5 segundos');
}, 5000);
```
## Explique como funciona e de um exemplo de `process`.
É a instancia global do EventEmitter, que controla todas os eventos do Node e pode ser acessado em qualquer trecho do código. Atráves dele, é possível controlar os eventos disparados durante toda a execução do código, como a detecção de erros ou o encerramento do código.
```js
process.on('uncaughtException', (err) => {
console.log(`Algo de errado não está certo: ${err}`);
});
```
## Criar um arquivo
```js
'use strict';
var fs = require('fs');
var write = fs.writeFileSync('./ex05.txt', 'Hello World!', 'utf8');
```
## Ler um arquivo
```
'use strict';
var fs = require('fs');
fs.readFile(path, options, callback_);('./ex05.txt', 'utf8', (err, result)=>{
if(err) throw err;
console.log(result);
});
```
## Editar conteúdo desse arquivo
```js
'use strict';
var fs = require('fs');
fs.writeFile('./ex05.txt', 'Daqui a pouco já vai ser excluido', 'utf8', (err, result)=>{
if(err) throw err;
console.log(result);
});
```
## Renomear o arquivo
```js
'use strict';
var fs = require('fs');
fs.rename('./ex05.txt', './renomeia.txt', err=>{
if(err) throw err;
console.log('Arquivo renomeado :)');
});
```
## Deletar arquivo
```js
'use strict';
var fs = require('fs');
fs.unlink('./renomeia.txt', (err)=>{
if(err) throw err;
console.log('Arquivo excluído :)');
});
```
## Desafio
```js
'use strict';
var http = require('http')
, fs = require('fs')
;
http.createServer((req, res)=>{
/* Verifica se a requisição é na origem. Se nã0 for, busca pelo arquivo */
if( req.url!=="/" ) {
var url = "." + req.url;
fs.readFile(url, (err, data)=>{
if(err) {
res.writeHead(404, {'Content-Type': 'text/html'});
res.write('<h2 style="font-family: Arial"> 404 :( </h2>');
res.end();
} else {
var type = 'text/' + url.match(/[^\.]+$/g);
res.writeHead(200, {'Content-Type': type});
res.write(data);
res.end();
}
});
} else {
res.writeHead(200, {'Content-Type': 'text/html'});
var html = fs.readFileSync('./index.html', 'utf8');
res.write(html);
res.end();
}
}).listen(3000, ()=>{
console.log('Aplicação rodando em localhost:3000')
});
```
**Servidor Web (200:OK)**
**404**
 | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 05 - Exercício
**user:** [vitorcapretz](https://github.com/vitorcapretz)
**autor:** Vitor Capretz
**date:** 1465951250011
## 1. Instale algum gerenciador de versão do Node.js e instale a versão mais atual como padrão, enquanto escrevo é a versão 5.4.0
#### Instalação do `nvm` via cUrl
```
vitor@vitor-ThinkPad-T440:/var/www/html/be-mean-modulo-nodejs$ curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.31.1/install.sh | bash
```
#### Checando a instalação
```
vitor@vitor-ThinkPad-T440:~$ command -v nvm
nvm
```
#### Versão do `nvm`
```
vitor@vitor-ThinkPad-T440:~$ nvm --version
0.31.1
```
#### Versão do node, não há necessidade de atualização por ser a última
```
vitor@vitor-ThinkPad-T440:~$ node --version
v6.2.1
```
## 2. Inicie um projeto novo para essa aula, com o npm e instale, salvando no `package.json`
```
vitor@vitor-ThinkPad-T440:/var/www/html/workshop-be-mean/nodejs/proj-bemean$ npm init
```
#### Arquivo package.json finalizado
```js
{
"name": "proj-bemean",
"version": "0.0.1",
"description": "projeto do bemean aula 05",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"author": "vitorcapretz",
"license": "ISC"
}
```
#### Instalando dependência local
```
vitor@vitor-ThinkPad-T440:/var/www/html/workshop-be-mean/nodejs/proj-bemean$ npm i --save bower
proj-bemean@0.0.1 /var/www/html/workshop-be-mean/nodejs/proj-bemean
└── bower@1.7.9
npm WARN proj-bemean@0.0.1 No repository field.
```
#### Instalando dependência de desenvolvimento
```
vitor@vitor-ThinkPad-T440:/var/www/html/workshop-be-mean/nodejs/proj-bemean$ npm i --save-dev socket.io
proj-bemean@0.0.1 /var/www/html/workshop-be-mean/nodejs/proj-bemean
└─┬ socket.io@1.4.6
├─┬ debug@2.2.0
│ └── ms@0.7.1
├─┬ engine.io@1.6.9
│ ├─┬ accepts@1.1.4
│ │ ├─┬ mime-types@2.0.14
│ │ │ └── mime-db@1.12.0
│ │ └── negotiator@0.4.9
│ ├── base64id@0.1.0
│ ├─┬ engine.io-parser@1.2.4
│ │ ├── after@0.8.1
│ │ ├── arraybuffer.slice@0.0.6
│ │ ├── base64-arraybuffer@0.1.2
│ │ ├── blob@0.0.4
│ │ ├── has-binary@0.1.6
│ │ └── utf8@2.1.0
│ └─┬ ws@1.0.1
│ ├── options@0.0.6
│ └── ultron@1.0.2
├─┬ has-binary@0.1.7
│ └── isarray@0.0.1
├─┬ socket.io-adapter@0.4.0
│ └─┬ socket.io-parser@2.2.2
│ ├── debug@0.7.4
│ └── json3@3.2.6
├─┬ socket.io-client@1.4.6
│ ├── backo2@1.0.2
│ ├── component-bind@1.0.0
│ ├── component-emitter@1.2.0
│ ├─┬ engine.io-client@1.6.9
│ │ ├── component-inherit@0.0.3
│ │ ├── has-cors@1.1.0
│ │ ├── parsejson@0.0.1
│ │ ├── parseqs@0.0.2
│ │ ├── xmlhttprequest-ssl@1.5.1
│ │ └── yeast@0.1.2
│ ├── indexof@0.0.1
│ ├── object-component@0.0.3
│ ├─┬ parseuri@0.0.4
│ │ └─┬ better-assert@1.0.2
│ │ └── callsite@1.0.0
│ └── to-array@0.1.4
└─┬ socket.io-parser@2.2.6
├── benchmark@1.0.0
├── component-emitter@1.1.2
└── json3@3.3.2
npm WARN proj-bemean@0.0.1 No repository field.
```
#### Dependência opcional
```
vitor@vitor-ThinkPad-T440:/var/www/html/workshop-be-mean/nodejs/proj-bemean$ npm i --save-optional mocha
npm WARN deprecated jade@0.26.3: Jade has been renamed to pug, please install the latest version of pug instead of jade
npm WARN deprecated minimatch@0.3.0: Please update to minimatch 3.0.2 or higher to avoid a RegExp DoS issue
proj-bemean@0.0.1 /var/www/html/workshop-be-mean/nodejs/proj-bemean
└─┬ mocha@2.5.3
├── commander@2.3.0
├── diff@1.4.0
├── escape-string-regexp@1.0.2
├─┬ glob@3.2.11
│ ├── inherits@2.0.1
│ └─┬ minimatch@0.3.0
│ ├── lru-cache@2.7.3
│ └── sigmund@1.0.1
├── growl@1.9.2
├─┬ jade@0.26.3
│ ├── commander@0.6.1
│ └── mkdirp@0.3.0
├─┬ mkdirp@0.5.1
│ └── minimist@0.0.8
├── supports-color@1.2.0
└── to-iso-string@0.0.2
npm WARN proj-bemean@0.0.1 No repository field.
```
**Arquivo `package.json após dependências**
```js
{
"name": "proj-bemean",
"version": "0.0.4",
"description": "projeto do bemean aula 05",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1",
"ScriptJs": "node server.js"
},
"author": "vitorcapretz",
"license": "ISC",
"dependencies": {
"bower": "^1.7.9"
},
"devDependencies": {
"socket.io": "^1.4.6"
},
"optionalDependencies": {
"mocha": "^2.5.3"
}
}
```
## 3. Crie e execute um script, via npm, que mostre uma mensagem no console com a global, que possui caminho para o diretório atual.
#### Arquivo `package.json` atualizado
```js
{
"name": "proj-bemean",
"version": "0.0.1",
"description": "projeto do bemean aula 05",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1",
"ScriptJs": "node server.js"
},
"author": "vitorcapretz",
"license": "ISC"
}
```
#### Arquivo `server.js`
```js
console.log(__dirname);
```
#### Resultado no terminal
```
vitor@vitor-ThinkPad-T440:/var/www/html/workshop-be-mean/nodejs/proj-bemean$ npm run ScriptJs
> proj-bemean@0.0.1 ScriptJs /var/www/html/workshop-be-mean/nodejs/proj-bemean
> node server.js
/var/www/html/workshop-be-mean/nodejs/proj-bemean
```
## 4. Cite 5 globais do Node.js e pelo menos 1 exemplo de cada.
#### dirname e filename
Ambas são muito parecidas, a variável global `__dirname` retorna o caminho completo do diretório, enquanto a variável `__filename` inclui também o nome do próprio arquivo.
```js
console.log(__dirname); // /var/www/html/workshop-be-mean/nodejs/proj-bemean
console.log(__filename); // /var/www/html/workshop-be-mean/nodejs/proj-bemean/server.js
```
#### setInterval e setTimeout
Também muito semelhantes, ambas recebem uma função de callback e um tempo em milisegundos. A diferença é que `setInterval` executa a função callback infinitamente a cada X milisegundos passados como parâmetro, enquanto a `setTimeout` aguarda por X milisegundos e executa a função callback apenas uma vez.
```js
'use strict';
const interval = setInterval(() => {
console.log('loop');
}, 500);
setTimeout(() => {
clearInterval(interval);
console.log('stopped infinite loop');
}, 5000);
```
#### console
Conhecido principalmente por permitir a impressão de dados, um de seus métodos muito utilizados é o `console.log`
```js
console.log('just a print');
```
#### Buffer - classe
Usado para lidar com dados binários
```js
'use strict';
const buf = new Buffer(10);
console.log(buf); // <Buffer 00 00 00 00 00 00 00 00 a0 6b>
```
## 5. Explique como funciona e de um exemplo de `process`.
O `process` é uma váriavel global que disponibiliza ao desenvolvedor informações sobre o atual estado da aplicação.
O objeto `process` é uma instância do `EventEmitter`.
**Exemplo de impressão de uso de memória**
```js
console.log(process.memoryUsage()); // { rss: 23867392, heapTotal: 8384512, heapUsed: 4230040 }
```
## 6. Gerenciamento de arquivos usando FileSystem: Criar, Ler, Editar, Renomear e Deletar
```js
"use strict";
const fs = require('fs');
let test_file = "test.txt";
fs.writeFileSync(test_file, 'Olá mundo com teste de criação de arquivo', 'utf8');
console.log('file created');
let file_content = fs.readFileSync(test_file, 'utf8');
console.log(file_content);
fs.writeFileSync(test_file, file_content + ', versão editada', 'utf8');
let new_test_file = "renomeado_" + test_file;
fs.rename(test_file, new_test_file, () => {
console.log('file renamed');
fs.unlink(new_test_file, () => {
console.log('ok, deleted file');
});
});
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 04 - Exercício
**user:** [victorvoid](https://github.com/victorvoid)
**autor:** Victor Igor
## Instale algum gerenciador de versão do Node.js e instale a versão mais atual como padrão, enquanto escrevo é a versão 5.4.0
```js
sudo npm install -g nvm
/usr/bin/nvm -> /usr/lib/node_modules/nvm/bin/nvm
/usr/lib
└─┬ nvm@0.0.3
└── mkdirp@0.3.5
node -v
v5.4.1
```
## Inicie um projeto novo para essa aula, com o npm e instale, salvando no package.json
```js
/* INICIANDO */
npm init
This utility will walk you through creating a package.json file.
It only covers the most common items, and tries to guess sensible defaults.
See `npm help json` for definitive documentation on these fields
and exactly what they do.
Use `npm install <pkg> --save` afterwards to install a package and
save it as a dependency in the package.json file.
Press ^C at any time to quit.
name: (class05) class05
version: (1.0.0)
description: exercitando a aula 05
entry point: (index.js)
test command:
git repository:
keywords: node, npm
author: Victor Igor
license: (ISC)
About to write to /home/victorigor/Área de Trabalho/workshop-be-mean/NodeJS - Be Mean /Arquivos de Exercícios/class05/package.json:
{
"name": "class05",
"version": "1.0.0",
"description": "exercitando a aula 05",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"keywords": [
"node",
"npm"
],
"author": "Victor Igor",
"license": "ISC"
}
```
- dependência local
```js
npm i --save yo
npm WARN deprecated npmconf@2.1.2: this package has been reintegrated into npm and is now out of date with respect to npm
> yo@1.7.0 postinstall /home/victorigor/Área de Trabalho/workshop-be-mean/NodeJS - Be Mean /Arquivos de Exercícios/class05/node_modules/yo
> yodoctor
Yeoman Doctor
Running sanity checks on your system
✔ Global configuration file is valid
✔ NODE_PATH matches the npm root
✔ Node.js version
✔ No .bowerrc file in home directory
✔ No .yo-rc.json file in home directory
✔ npm version
Everything looks all right!
class05@1.0.0 /home/victorigor/Área de Trabalho/workshop-be-mean/NodeJS - Be Mean /Arquivos de Exercícios/class05
└─┬ yo@1.7.0
├── async@1.5.2
├─┬ chalk@1.1.1
│ ├─┬ ansi-styles@2.2.0
│ │ └── color-convert@1.0.0
│ ├── escape-string-regexp@1.0.5
│ ├── has-ansi@2.0.0
│ ├── strip-ansi@3.0.1
│ └── supports-color@2.0.0
├── cli-list@0.1.6
├─┬ configstore@1.4.0
│ ├── graceful-fs@4.1.3
│ ├─┬ mkdirp@0.5.1
│ │ └── minimist@0.0.8
│ ├── object-assign@4.0.1
│ ├── os-tmpdir@1.0.1
│ ├── osenv@0.1.3
│ ├── uuid@2.0.1
│ ├─┬ write-file-atomic@1.1.4
│ │ ├── imurmurhash@0.1.4
│ │ └── slide@1.1.6
│ └── xdg-basedir@2.0.0
├─┬ cross-spawn-async@2.1.9
│ ├─┬ lru-cache@4.0.0
│ │ ├── pseudomap@1.0.2
│ │ └── yallist@2.0.0
│ └─┬ which@1.2.4
│ ├─┬ is-absolute@0.1.7
│ │ └── is-relative@0.1.3
│ └── isexe@1.1.2
├── figures@1.4.0
├─┬ fullname@2.1.0
│ ├─┬ npmconf@2.1.2
│ │ ├─┬ config-chain@1.1.10
│ │ │ └── proto-list@1.2.4
│ │ ├── inherits@2.0.1
│ │ ├── ini@1.3.4
│ │ ├─┬ nopt@3.0.6
│ │ │ └── abbrev@1.0.7
│ │ ├─┬ once@1.3.3
│ │ │ └── wrappy@1.0.1
│ │ ├── semver@4.3.6
│ │ └── uid-number@0.0.5
│ ├── pify@2.3.0
│ └─┬ pinkie-promise@2.0.0
│ └── pinkie@2.0.4
├─┬ got@5.5.0
│ ├─┬ create-error-class@2.0.1
│ │ └── capture-stack-trace@1.0.0
│ ├── duplexer2@0.1.4
│ ├── is-plain-obj@1.1.0
│ ├── is-redirect@1.0.0
│ ├── is-retry-allowed@1.0.0
│ ├── is-stream@1.0.1
│ ├── lowercase-keys@1.0.0
│ ├── node-status-codes@1.0.0
│ ├─┬ parse-json@2.2.0
│ │ └─┬ error-ex@1.3.0
│ │ └── is-arrayish@0.2.1
│ ├── read-all-stream@3.1.0
│ ├─┬ readable-stream@2.0.5
│ │ ├── core-util-is@1.0.2
│ │ ├── isarray@0.0.1
│ │ ├── process-nextick-args@1.0.6
│ │ ├── string_decoder@0.10.31
│ │ └── util-deprecate@1.0.2
│ ├── timed-out@2.0.0
│ ├── unzip-response@1.0.0
│ └─┬ url-parse-lax@1.0.0
│ └── prepend-http@1.0.3
├─┬ humanize-string@1.0.1
│ └── decamelize@1.2.0
├─┬ inquirer@0.11.4
│ ├── ansi-escapes@1.2.0
│ ├── ansi-regex@2.0.0
│ ├─┬ cli-cursor@1.0.2
│ │ └─┬ restore-cursor@1.0.1
│ │ └── exit-hook@1.1.1
│ ├── cli-width@1.1.1
│ ├─┬ readline2@1.0.1
│ │ ├── code-point-at@1.0.0
│ │ ├── is-fullwidth-code-point@1.0.0
│ │ └── mute-stream@0.0.5
│ ├── run-async@0.1.0
│ ├── rx-lite@3.1.2
│ ├── string-width@1.0.1
│ └── through@2.3.8
├─┬ insight@0.7.0
│ ├── inquirer@0.10.1
│ ├─┬ lodash.debounce@3.1.1
│ │ └── lodash._getnative@3.9.1
│ ├─┬ os-name@1.0.3
│ │ ├─┬ osx-release@1.1.0
│ │ │ └── minimist@1.2.0
│ │ └─┬ win-release@1.1.1
│ │ └── semver@5.1.0
│ ├─┬ request@2.69.0
│ │ ├── aws-sign2@0.6.0
│ │ ├── aws4@1.3.2
│ │ ├── bl@1.0.3
│ │ ├── caseless@0.11.0
│ │ ├─┬ combined-stream@1.0.5
│ │ │ └── delayed-stream@1.0.0
│ │ ├── extend@3.0.0
│ │ ├── forever-agent@0.6.1
│ │ ├── form-data@1.0.0-rc3
│ │ ├─┬ har-validator@2.0.6
│ │ │ ├─┬ commander@2.9.0
│ │ │ │ └── graceful-readlink@1.0.1
│ │ │ └─┬ is-my-json-valid@2.13.1
│ │ │ ├── generate-function@2.0.0
│ │ │ ├─┬ generate-object-property@1.2.0
│ │ │ │ └── is-property@1.0.2
│ │ │ └── jsonpointer@2.0.0
│ │ ├─┬ hawk@3.1.3
│ │ │ ├── boom@2.10.1
│ │ │ ├── cryptiles@2.0.5
│ │ │ ├── hoek@2.16.3
│ │ │ └── sntp@1.0.9
│ │ ├─┬ http-signature@1.1.1
│ │ │ ├── assert-plus@0.2.0
│ │ │ ├─┬ jsprim@1.2.2
│ │ │ │ ├── extsprintf@1.0.2
│ │ │ │ ├── json-schema@0.2.2
│ │ │ │ └── verror@1.3.6
│ │ │ └─┬ sshpk@1.7.4
│ │ │ ├── asn1@0.2.3
│ │ │ ├─┬ dashdash@1.13.0
│ │ │ │ └── assert-plus@1.0.0
│ │ │ ├── ecc-jsbn@0.1.1
│ │ │ ├── jodid25519@1.0.2
│ │ │ ├── jsbn@0.1.0
│ │ │ └── tweetnacl@0.14.1
│ │ ├── is-typedarray@1.0.0
│ │ ├── isstream@0.1.2
│ │ ├── json-stringify-safe@5.0.1
│ │ ├─┬ mime-types@2.1.10
│ │ │ └── mime-db@1.22.0
│ │ ├── node-uuid@1.4.7
│ │ ├── oauth-sign@0.8.1
│ │ ├── qs@6.0.2
│ │ ├── stringstream@0.0.5
│ │ └── tunnel-agent@0.4.2
│ └── tough-cookie@2.2.1
├── lodash@3.10.1
├─┬ meow@3.7.0
│ ├─┬ camelcase-keys@2.0.0
│ │ └── camelcase@2.1.0
│ ├─┬ loud-rejection@1.3.0
│ │ ├── array-find-index@1.0.1
│ │ └── signal-exit@2.1.2
│ ├── map-obj@1.0.1
│ ├── minimist@1.2.0
│ ├─┬ normalize-package-data@2.3.5
│ │ ├── hosted-git-info@2.1.4
│ │ ├─┬ is-builtin-module@1.0.0
│ │ │ └── builtin-modules@1.1.1
│ │ └─┬ validate-npm-package-license@3.0.1
│ │ ├─┬ spdx-correct@1.0.2
│ │ │ └── spdx-license-ids@1.2.0
│ │ └─┬ spdx-expression-parse@1.0.2
│ │ └── spdx-exceptions@1.0.4
│ ├─┬ redent@1.0.0
│ │ ├── indent-string@2.1.0
│ │ └── strip-indent@1.0.1
│ └── trim-newlines@1.0.0
├─┬ npm-keyword@4.2.0
│ └── registry-url@3.0.3
├── opn@3.0.3
├─┬ package-json@2.3.1
│ ├─┬ rc@1.1.6
│ │ ├── deep-extend@0.4.1
│ │ ├── minimist@1.2.0
│ │ └── strip-json-comments@1.0.4
│ └── semver@5.1.0
├─┬ read-pkg-up@1.0.1
│ ├─┬ find-up@1.1.2
│ │ └── path-exists@2.1.0
│ └─┬ read-pkg@1.1.0
│ ├─┬ load-json-file@1.1.0
│ │ └─┬ strip-bom@2.0.0
│ │ └── is-utf8@0.2.1
│ └── path-type@1.1.0
├─┬ repeating@2.0.0
│ └─┬ is-finite@1.0.1
│ └── number-is-nan@1.0.0
├─┬ root-check@1.0.0
│ ├─┬ downgrade-root@1.1.0
│ │ ├── default-uid@1.0.0
│ │ └── is-root@1.0.0
│ └─┬ sudo-block@1.2.0
│ └── is-docker@1.0.0
├─┬ sort-on@1.2.2
│ ├── arrify@1.0.1
│ └─┬ dot-prop@2.4.0
│ └── is-obj@1.0.0
├── string-length@1.0.1
├── titleize@1.0.0
├─┬ update-notifier@0.6.1
│ ├─┬ boxen@0.3.1
│ │ ├── filled-array@1.1.0
│ │ └── widest-line@1.0.0
│ ├── is-npm@1.0.0
│ ├── latest-version@2.0.0
│ └─┬ semver-diff@2.1.0
│ └── semver@5.1.0
├─┬ user-home@2.0.0
│ └── os-homedir@1.0.1
├─┬ yeoman-character@1.1.0
│ └─┬ supports-color@3.1.2
│ └── has-flag@1.0.0
├─┬ yeoman-doctor@2.1.0
│ ├─┬ bin-version-check@2.1.0
│ │ ├─┬ bin-version@1.0.4
│ │ │ └─┬ find-versions@1.2.1
│ │ │ └── semver-regex@1.0.0
│ │ ├── minimist@1.2.0
│ │ └─┬ semver-truncate@1.1.0
│ │ └── semver@5.1.0
│ ├─┬ each-async@1.1.1
│ │ ├── onetime@1.1.0
│ │ └── set-immediate-shim@1.0.1
│ ├── log-symbols@1.0.2
│ ├── object-values@1.0.0
│ ├── semver@5.1.0
│ └─┬ twig@0.8.8
│ ├─┬ minimatch@0.2.14
│ │ ├── lru-cache@2.7.3
│ │ └── sigmund@1.0.1
│ └─┬ walk@2.3.9
│ └── foreachasync@3.0.0
├─┬ yeoman-environment@1.5.2
│ ├─┬ debug@2.2.0
│ │ └── ms@0.7.1
│ ├── diff@2.2.1
│ ├─┬ globby@4.0.0
│ │ ├─┬ array-union@1.0.1
│ │ │ └── array-uniq@1.0.2
│ │ └─┬ glob@6.0.4
│ │ ├── inflight@1.0.4
│ │ ├─┬ minimatch@3.0.0
│ │ │ └─┬ brace-expansion@1.1.3
│ │ │ ├── balanced-match@0.3.0
│ │ │ └── concat-map@0.0.1
│ │ └── path-is-absolute@1.0.0
│ ├── grouped-queue@0.3.2
│ ├─┬ mem-fs@1.1.2
│ │ ├─┬ through2@2.0.1
│ │ │ └── xtend@4.0.1
│ │ ├─┬ vinyl@1.1.1
│ │ │ ├── clone@1.0.2
│ │ │ ├── clone-stats@0.0.1
│ │ │ └── replace-ext@0.0.1
│ │ └─┬ vinyl-file@1.3.0
│ │ └─┬ strip-bom-stream@1.0.0
│ │ └── first-chunk-stream@1.0.0
│ ├── text-table@0.2.0
│ └── untildify@2.1.0
└─┬ yosay@1.1.0
├── minimist@1.2.0
├── pad-component@0.0.1
├─┬ taketalk@1.0.0
│ ├── get-stdin@4.0.1
│ └── minimist@1.2.0
└── word-wrap@1.1.0
```
- Uma dependência local de desenvolvimento
```js
npm i --save-dev jasmine
class05@1.0.0 /home/victorigor/Área de Trabalho/workshop-be-mean/NodeJS - Be Mean /Arquivos de Exercícios/class05
├─┬ jasmine@2.4.1
│ ├── exit@0.1.2
│ ├─┬ glob@3.2.11
│ │ └─┬ minimatch@0.3.0
│ │ └── lru-cache@2.7.3
│ └── jasmine-core@2.4.1
└─┬ yo@1.7.0
└─┬ yeoman-doctor@2.1.0
└─┬ twig@0.8.8
└─┬ minimatch@0.2.14
└── lru-cache@2.7.3
```
- Uma dependência local opcional
```js
npm i --save-optional colors
class05@1.0.0 /home/victorigor/Área de Trabalho/workshop-be-mean/NodeJS - Be Mean /Arquivos de Exercícios/class05
└── colors@1.1.2
```
```js
/* COMO FICOU O PACKAGE: */
cat package.json
{
"name": "class05",
"version": "1.0.0",
"description": "exercitando a aula 05",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"keywords": [
"node",
"npm"
],
"author": "Victor Igor",
"license": "ISC",
"dependencies": {
"yo": "^1.7.0"
},
"devDependencies": {
"jasmine": "^2.4.1"
},
"optionalDependencies": {
"colors": "^1.1.2"
}
}
```
## Crie e execute um script, via npm, que mostre uma mensagem no console com a global, que possui caminho para o diretório atual.
script.js:
```js
console.log('UUUIUUUUU vc está aqui: '+__dirname);
```
```js
//executando:
sudo npm run ondeEstou
ondeEstou /home/victorigor/Área de Trabalho/workshop-be-mean/NodeJS - Be Mean /Aulas/npm
> node script.js
UUUIUUUUU vc está aqui: /home/victorigor/Área de Trabalho/workshop-be-mean/NodeJS - Be Mean /Aulas/npm
```
## Cite 5 globais do Node.js e pelo menos 1 exemplo de cada.
```js
/*1 - filename */
console.log('Diretorio com o nome do arquivo é: '+__filename);
```
```js
/*2 - dirname */
console.log('Eu estou em '+__dirname)
```
```js
/*3 - buffer */
var buffer = new Buffer('Ola mucura =)');
console.log(buffer.toString());
```
```js
/*4 - setTimeout */
setTimeout(()=>{
console.log('Ola estou usando timeout');
}, 1000);
```
```js
/*5 - setInterval */
setInterval(()=>{
console.log('ola estou usando setInterval');
}, 1000);
```
## Explique como funciona e de um exemplo de process
O *process* é um objeto global e uma instancia do *EventEmitter*, então com ele você tem a capacidade de manipular e transmitir eventos.
Exemplo:
```js
process.on('exit', () => console.log('Executando apenas ao final do processo!!!: '));
```
# Exercício de FS Aula 05 Parte 2
## Criar um arquivo
```js
'use strict';
const fs = require('fs');
fs.writeFile('./index.txt', 'Estou criando e escrevendo', 'utf-8', (err)=>{
if (err) throw err;
console.log('Arquivo criado');
});
```
## Ler um arquivo
```js
const fs = require('fs');
fs.readFile('./index.txt', 'utf-8', (err, result)=>{
if (err) throw err;
console.log(result);
});
```
## Editar o conteúdo desse arquivo
```js
'use strict';
const fs = require('fs');
fs.readFile('./index.txt', 'utf-8', (err, data)=>{
if (err) throw err;
data = data.replace('escrevendo', 'EDITEI AQUI');
fs.writeFile('./index.txt', data, 'utf-8', (err)=>{
if (err) throw err;
console.log('Arquivo modificado com sucesso!');
});
});
```
## Deletar arquivo
```js
'use strict';
const fs = require('fs');
fs.unlink('index.txt', (err)=>{
if (err) throw err;
console.log('Arquivo deletado!');
})
```
## Renomear arquivo
```js
const fs = require('fs');
fs.rename('./index.txt', 'index2.txt', (err)=>{
if (err) throw err;
console.log('Arquivo renomeiado');
});
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 05 - Parte 1 - Exercícios
**User:** [angelorubin](https://github.com/angelorubin)
**Autor:** Angelo Rogério Rubin
**Date:** 1453919880
## Instale algum gerenciador de versão do Node.js e instale a versão mais atual como padrão, enquanto escrevo é a versão 5.4.0
PS C:\Projetos\pokemons-api> npm install nvm-win
pokemons-api@0.0.1 C:\Projetos\pokemons-api
├─┬ nodemon@1.8.1
│ ├─┬ chokidar@1.4.2
│ │ └─┬ readdirp@2.0.0
│ │ └── readable-stream@2.0.5
│ └─┬ update-notifier@0.5.0
│ └─┬ latest-version@1.0.1
│ └─┬ package-json@1.2.0
│ └─┬ got@3.3.1
│ ├─┬ duplexify@3.4.2
│ │ └── readable-stream@2.0.5
│ └─┬ read-all-stream@3.0.1
│ └── readable-stream@2.0.5
└── nvm-win@0.2.4 extraneous
npm WARN optional Skipping failed optional dependency /chokidar/fsevents:
npm WARN notsup Not compatible with your operating system or architecture: fsevents@1.0.6
npm WARN mongodb-core@1.2.32 requires a peer of kerberos@~0.0 but none was installed.
npm WARN pokemons-api@0.0.1 No repository field.
PS C:\Projetos\pokemons-api>
## Inicie um projeto novo para essa aula, com o npm e instale, salvando no package.json:
PS C:\Projetos\pokemons-api> npm init
This utility will walk you through creating a package.json file.
It only covers the most common items, and tries to guess sensible defaults.
See `npm help json` for definitive documentation on these fields
and exactly what they do.
Use `npm install <pkg> --save` afterwards to install a package and
save it as a dependency in the package.json file.
Press ^C at any time to quit.
name: (pokemons-api)
version: (0.0.1)
git repository:
license: (MIT) MIT
About to write to C:\Projetos\pokemons-api\package.json:
{
"name": "pokemons-api",
"version": "0.0.1",
"description": "API Pokemons",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1",
"roda": "node npm/script.js"
},
"keywords": [
"pokemons",
"node",
"mongodb",
"webschool"
],
"author": "Angelo Rubin",
"license": "MIT",
"dependencies": {
"mongoose": "^4.3.6",
"nodemon": "^1.8.1"
},
"devDependencies": {
"jasmine": "^2.4.1"
}
}
Is this ok? (yes) yes
1 - Dependência Local
PS C:\Projetos\pokemons-api> npm i express -S
pokemons-api@0.0.1 C:\Projetos\pokemons-api
├── express@4.13.3 extraneous
└── nvm-win@0.2.4 extraneous
npm WARN optional Skipping failed optional dependency /chokidar/fsevents:
npm WARN notsup Not compatible with your operating system or architecture: fsevents@1.0.6
npm WARN mongodb-core@1.2.32 requires a peer of kerberos@~0.0 but none was installed.
npm WARN pokemons-api@0.0.1 No repository field.
2 - Dependência Local de Desenvolvimento
PS C:\Projetos\pokemons-api> npm i express -SD
pokemons-api@0.0.1 C:\Projetos\pokemons-api
└── nvm-win@0.2.4 extraneous
npm WARN optional Skipping failed optional dependency /chokidar/fsevents:
npm WARN notsup Not compatible with your operating system or architecture: fsevents@1.0.6
npm WARN mongodb-core@1.2.32 requires a peer of kerberos@~0.0 but none was installed.
npm WARN pokemons-api@0.0.1 No repository field.
3 - Dependência Local Opcional
PS C:\Projetos\pokemons-api> npm i color -SO
pokemons-api@0.0.1 C:\Projetos\pokemons-api
├─┬ color@0.11.1
│ ├── color-convert@0.5.3
│ └─┬ color-string@0.3.0
│ └── color-name@1.1.1
├── express@4.13.3
└── nvm-win@0.2.4 extraneous
npm WARN optional Skipping failed optional dependency /chokidar/fsevents:
npm WARN notsup Not compatible with your operating system or architecture: fsevents@1.0.6
npm WARN mongodb-core@1.2.32 requires a peer of kerberos@~0.0 but none was installed.
npm WARN pokemons-api@0.0.1 No repository field.
## Crie e execute um script, via 'npm', que mostre uma mensagem no console com a global, que possui caminho para o diretório atual.
PS C:\Projetos\pokemons-api> npm run script
> pokemons-api@0.0.1 script C:\Projetos\pokemons-api
> node npm/run-script-by-npm.js
Fui executado pelo comando run do npm.
## Cite 5 globais do Node.js e pelo menos 1 exemplo de cada.
### __dirname
Retorna o nome do diretório em que o script esta atualmente em execução.
Exemplo:
console.log(__dirname);
Resultado:
PS C:\Projetos\be-mean-instagram\be-mean-code-examples\file-system> node _dirname.js
C:\Projetos\be-mean-instagram\be-mean-code-examples\file-system
### _filename
Retorna o nome do arquivo do código que está sendo executado. Mostra o caminho absoluto do arquivo.
Exemplo:
console.log(__filename);
Resultado:
PS C:\Projetos\be-mean-instagram\be-mean-code-examples\file-system> node _filename.js
C:\Projetos\be-mean-instagram\be-mean-code-examples\file-system\_filename.js
### clearTimeout(t)
Para um temporizador que foi criado anteriormente com setTimeout (). O retorno de chamada não será executado.
Exemplo:
var timeout = setTimeout(function(str1, str2) {
console.log(str1 + " " + str2);
}, 1000, "Hello.", "How are you?");
clearTimeout(timeout);
### clearInterval(t)
Para um temporizador que foi criado anteriormente com setInterval (). O retorno de chamada não será executado.
As funções de temporizador são variáveis globais.
Exemplo:
var i = 1;
var interval = setInterval(function() { alert(i++) }, 2000);
clearInterval(interval);
### console.log()
O módulo de console fornece um console de depuração simples que é semelhante ao mecanismo de console JavaScript fornecido pelos navegadores da web.
O módulo exporta dois componentes específicos:
Uma classe de console com métodos tais como console.log (), console.error () e console.warn () que pode ser usada para escrever para qualquer fluxo Node.js.
Uma instância do console global configurado para escrever para stdout e stderr.
Como este objeto é global, ele pode ser usado sem chamar require ('console').
Exemplo:
console.log('hello world'); // hello world
## Explique como funciona e de um exemplo de 'process'.
O objeto process é um objeto global e pode ser acessado de qualquer lugar. Ele é uma instância de [EventEmitter](http://devdocs.io/node/events#events_class_events_eventemitter "EventEmitter").
Exemplo:
process.on('exit', (code) => {
setTimeout(() => {
console.log('This will not run');
}, 0);
console.log('About to exit with code:', code);
});
# Node.js - Aula 05 - Parte 2 - Exercícios
## File System
### Criar um arquivo.
'use strict';
const fs = require('fs');
fs.writeFile('mensagem.txt', 'Olá, eu sou um arquivo.', (err) => {
if (err) throw err;
console.log('Arquivo criado e salvo com sucesso.');
});
Resultado:
PS C:\Projetos\be-mean-instagram\be-mean-code-examples\file-system> node criar-arquivo.js
Arquivo criado e salvo com sucesso.
### Ler um arquivo.
'use strict';
const fs = require('fs');
fs.readFile('mensagem.txt', (err, data) => {
if (err) throw err;
console.log(data.toString());
});
Resultado:
PS C:\Projetos\be-mean-instagram\be-mean-code-examples\file-system> node ler-arquivo.js
Olá, eu sou um arquivo.
### Editar conteúdo desse arquivo.
'use strict';
const fs = require('fs');
fs.readFile('mensagem.txt', 'utf-8', (err, data) => {
if (err) throw err;
const content = data + "\n Sou um novo conteúdo adicionado ao arquivo.";
fs.writeFile('mensagem.txt', content, 'utf-8', (err) => {
if (err) throw err;
console.log(content);
});
});
Resultado:
PS C:\Projetos\be-mean-instagram\be-mean-code-examples\file-system> node editar-arquivo.js
Olá, eu sou um arquivo.
Sou um novo conteúdo adicionado ao arquivo.
### Deletar arquivo.
'use strict';
const fs = require('fs');
fs.unlink('mensagem.txt', (err) => {
if (err) throw err;
console.log('Arquivo deletado com sucesso.');
});
Resultado:
PS C:\Projetos\be-mean-instagram\be-mean-code-examples\file-system> node deletar-arquivo.js
Arquivo deletado com sucesso.
### Renomear o arquivo.
'use strict';
const fs = require('fs');
fs.rename('mensagem.txt', 'mensagem-renomeada.txt', (err, data) => {
if (err) throw err;
console.log('Arquivo renomeado com sucesso.');
});
Resultado:
PS C:\Projetos\be-mean-instagram\be-mean-code-examples\file-system> node renomear-arquivo.js
Arquivo renomeado com sucesso.
# Desafio: Criar um servidor web de arquivos estáticos (CSS, HTML, JS).
app.js
'use strict';
const http = require('http');
const fs = require('fs');
const path = require('path');
http.createServer((request, response) => {
let filePath = '.' + request.url;
if (filePath == './')
filePath = './index.html';
let extname = path.extname(filePath);
switch (extname) {
case '.css':
contentType = 'text/css';
break;
case '.js':
contentType = 'text/javascript';
break;
case '.html':
contentType = 'text/html';
break;
}
let contentType = 'text/html';
fs.readFile(filePath, (error, content) => {
if (error) {
if (error.code == 'ENOENT') {
fs.readFile('./404.html', (error, content) => {
response.writeHead(200, {
'Content-Type': contentType
});
response.end(content, 'utf-8');
});
}
}
else {
response.writeHead(200, {
'Content-Type': contentType
});
response.end(content, 'utf-8');
}
});
}).listen(3000);
console.log('Servidor rodando em http://localhost:3000');
### Acessando CSS
### Acessando JS
### Acessando HTML
### Pagina Não Encontrada.
 | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 05 - Exercício
**user:** [tuchedsf](https://github.com/tuchedsf)
**autor:** Diego Ferreira
## 1- Instale algum gerenciador de versão do Node.js e instale a versão mais atual como padrão, enquanto escrevo é a versão 5.4.0
Já o gerenciador de versão foi o nvm.
```
diego@MacBook-Air-Diego ~> curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.31.0/install.sh | bash
diego@MacBook-Air-Diego:~ diego$ nvm --version
0.31.0
node --version
v5.4.1
```
## 2- Inicie um projeto novo para essa aula, com o `npm` e instale, salvando no `package.json`:
```
diego@MacBook-Air-Diego ~/Mean> cd sdm-control/
diego@MacBook-Air-Diego ~/M/sdm-control> ls
diego@MacBook-Air-Diego ~/M/sdm-control> npm init
This utility will walk you through creating a package.json file.
It only covers the most common items, and tries to guess sensible defaults.
See `npm help json` for definitive documentation on these fields
and exactly what they do.
Use `npm install <pkg> --save` afterwards to install a package and
save it as a dependency in the package.json file.
Press ^C at any time to quit.
name: (sdm-control)
version: (1.0.0)
description: controle de chamados
entry point: (index.js)
test command:
git repository:
keywords: controle, sdm, sla
author: Diego Ferreira
license: (ISC)
About to write to /Users/diego/Mean/sdm-control/package.json:
{
"name": "sdm-control",
"version": "1.0.0",
"description": "controle de chamados",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"keywords": [
"controle",
"sdm",
"sla"
],
"author": "Diego Ferreira",
"license": "ISC"
}
Is this ok? (yes) y
```
###- 1 dependência local
```
diego@MacBook-Air-Diego ~/M/sdm-control> npm install --save mongoose
```
###- 1 dependência local de desenvolvimento
```
diego@MacBook-Air-Diego ~/M/sdm-control> npm install --dev jasmine
```
###- 1 dependência local opcional
```
diego@MacBook-Air-Diego ~/M/sdm-control> npm install --save morgan
```
###- Arquivo package.json após instalaçao das dependências
```
{
"name": "sdm-control",
"version": "1.0.0",
"description": "controle de chamados",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"keywords": [
"controle",
"sdm",
"sla"
],
"author": "Diego Ferreira",
"license": "ISC",
"dependencies": {
"mongoose": "^4.3.5"
},
"devDependencies": {
"jasmine": "^2.4.1"
},
"optionalDependencies": {
"morgan": "^1.7.0"
}
}
```
## Crie e execute um script, via `npm`, que mostre uma mensagem no console com a global, que possui caminho para o diretório atual.
```
//Arquivo script.js
console.log( __dirname );
//Package.json
{
"name": "sdm-control",
...
"scripts" : {
"roda" : "node script.js"
}
}
//Execução
diego@MacBook-Air-Diego ~/M/sdm-control> npm run roda
> sdm-control@1.0.0 roda /Users/diego/Mean/nodejs/sdm-control
> node script.js
/Users/diego/Mean/nodejs/sdm-control
```
## Cite 5 globais do Node.js e pelo menos 1 exemplo de cada.
1. `__dirname` retorna o nome do diretório que o script está sendo rodado.
```js
console.log(__dirname); // /Users/diego/Mean/nodejs/sdm-control
```
2. `__filename` retorna o endereço absoluto do arquivo executado.
```js
console.log(__dirname); // /Users/diego/Mean/nodejs/sdm-control/example.js
```
3. `console.log()` A classe console prove um debug simples. Uma utilização á funçao log, que imprime o conteúdo que estiver entre o parênteses.
```js
console.log("Diego"); // Diego
```
4. `Buffer` - A classe buffer é responsável por ler e manipular streams binários. Um método existente nesta classe é o compare, que compara buffers. E retorna 0 (identico), 1(se 1 buffer diferente), -1 (se segundo buffer diferente).
```
const buf1 = new Buffer('ABC');
const buf2 = new Buffer('BCD');
console.log(buf1.compare(buf1));
// Prints: 0
console.log(buf1.compare(buf2));
// Prints: -1
console.log(buf2.compare(buf1));
// Prints: 1
```
5. `require` Responsável por carregar algum recurso ao diretório atual para ser utilizado por algum script.
```js
const circle = require('./circle.js'); // Adiciona o conteudo do arquivo circle.js, no arquivo que o mesmo esta sendo requerido.
```
## Explique como funciona e de um exemplo de `process`.
Process é um objeto global do node que pode ser acessado de qualquer lugar. Ele é uma instancia do eventEmitter que é responsável por prover a arquitetura assíncrona ao nodejs.
ex.: Evento ' uncaughtException ' é emitido quando uma exceção acontece e o node retorna ao processo padrao. Por padrão, o Node.js lida com essas exceções , imprimindo o rastreamento de pilha para stderr e sair . Adicionando um manipulador para o evento ' uncaughtException ' substitui esse comportamento padrão.
```
process.on('uncaughtException', (err) => {
console.log(`Caught exception: ${err}`);
});
setTimeout(() => {
console.log('This will still run.');
}, 500);
// Intentionally cause an exception, but don't catch it.
nonexistentFunc();
console.log('This will not run.');
```
##Aula5 - Parte2
##1 - Criar um arquivo
```
var fs = require('fs');
// Sincrona - para funcao sincrona basta adicionar o Sync no método.
var write = fs.writeFileSync("./Hello.txt", "Hello mother fucker");
// Assincrona omite-se o Sync e inclui um callback na função
fs.writeFile("./Hello.txt", "teste", function(err,result){
if (err){
throw err;
}
console.log(result);
});
```
##2 - Ler um arquivo
```
var fs = require('fs');
//assincrono
fs.readFile('./dirNode2/hiWorld.txt','utf8', function(err,result){
if (err) throw err;
console.log(result);
});
//sincrono
var readSync = fs.readFileSync('./dirNode2/helloWord.txt','utf8');
console.log(readSync);
```
##3 - Editar counteúdo desse arquivo
```
var fs = require('fs');
//Assincrono
fs.open('./Hello.txt','r', function(err,result){
if (err){
throw err;
}
var write = fs.writeFileSync("./Hello.txt", "Hello mother fucker");
console.log(result);
});
```
##4 - Deletar um arquivo
```
var fs = require('fs');
fs.unlink('./Hello.txt', function(err){
if(err) throw err;
console.log('arquivo deletado!');
});
```
##5 - Renomear arquivo
```
var fs = require('fs');
//assincrono
fs.rename('./dirNode2/helloWord.txt', './dirNode2/helloWorld.txt', function(err){
if (err) throw err;
console.log("fui renomeado com node");
});
```
## Desafio:Criar um servidor web de arquivos estáticos: .css, .html, .js e etc...
```
'use strict';
const fs = require('fs');
const path = require('path');
const http = require('http');
http.createServer (function(req,resp){
let file = path.basename(req.url),
ext = path.extname(file);
switch (ext) {
case '.html':
readFile(file, 'text/html', resp);
break;
case '.css':
readFile(file, 'text/css', resp);
break;
case '.js':
readFile(file, 'text/javascript', resp);
break;
case '.jpg':
readFile(file, 'image/jpeg', resp);
break;
default:
error("404 - Nenhum arquivo encontrado", resp);
}
}).listen(3000,function(){
console.log("Servidor rodando na porta 3000!!!");
});
function readFile(file, contentType, resp){
fs.readFile(file, 'utf8', (err, data) => {
if (err) {
error(err.toString(),resp);
} else {
sucesso(resp,contentType,data);
}
});
}
function cabecalho(requestCode, contentType, resp){
resp.writeHead(requestCode, {'Content-Type':contentType+';charset=utf-8'});
}
function error(err, resp){
cabecalho(404, "text/html", resp);
resp.end(err.toString());
}
function sucesso(resp, contentType, data){
cabecalho(200, contentType, resp);
resp.end(data);
}
```
## Bibliografia
http://nomadev.com.br/node-js-o-que-%C3%A9-nvm-e-como-gerenciar-vers%C3%B5es-do-node/
https://nodejs.org/dist/latest-v4.x/docs/api/globals.html
https://nodejs.org/dist/latest-v4.x/docs/api/console.html
https://nodejs.org/dist/latest-v4.x/docs/api/buffer.html
https://nodejs.org/dist/latest-v4.x/docs/api/modules.html#modules_modules
https://nodejs.org/dist/latest-v4.x/docs/api/process.html#process_process
https://github.com/creationix/nvm
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 05 - Exercício
**user:** [gkal19](https://github.com/gkal19)
**autor:** Gabriel Kalani
## Instale algum gerenciador de versão do Node.js e instale a versão mais atual como padrão, enquanto escrevo é a versão 5.4.0
```js
npm -v
2.14.12
node -v
v4.2.6
```
## Inicie um projeto novo para essa aula, com o `npm` e instale, salvando no `package.json`:
```js
npm init
{
"name": "ex5",
"version": "2.14.12",
"description": "Exercício da Aula 05 de Node.JS",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"keywords": [
"webschool",
"suissa",
"node"
],
"author": "Gabriel Kalani",
"license": "MIT"
}
```
- 1 dependência local
```js
npm i -S mongoose
```
- 1 dependência local de desenvolvimento
```js
npm install -SD jasmine
```
- 1 dependência local opcional
```js
npm install -SO color
```
## Crie e execute um script, via `npm`, que mostre uma mensagem no console com a global, que possui caminho para o diretório atual.
```js
// test.js
console.log("Tá tranquilo, Tá compilado!");
```
```js
// package.json
"scripts":{
"rodar": "node test.js"
}
```
```js
npm run rodar
> node test.js
Tá tranquilo, Tá compilado!
```
## Cite 5 globais do Node.js e pelo menos 1 exemplo de cada.
```js
//Console serve para `printar` mensagens
console.log( 'Tá tranquilo, Tá compilado!');
//Require chama os módulos do Node.
require('http');
//setInterval executa uma função a cada "x" milisegundos.
setInterval(() => {
console.log(Date.now());
}, 1000);
//dirName Retorna o caminho do diretório atual.
console.log(__dirname);
//fileName Retorna o caminho do arquivo atual.
console.log(__filename);
```
## Explique como funciona e de um exemplo de `process`.
É um objeto global que manipula ou transmite eventos.
```js
// filename: process.js
'use strict';
process.on('uncaughtException', (err) => {
console.log('Oops! Parece que tivemos um erro...');
});
```
```js
node process.js
Oops! Parece que tivemos um erro...
```
## File System
### Criar um arquivo.
```js
// file: createFile
const fs = require('fs')
const write = fs.writeFileSync("./hello.txt","Tá tranquilo, Tá compilado!");
```
### Ler um arquivo.
```js
// file: readFile.js
const fs = require('fs');
fs.readFile('./meusArquivos/hello-world.txt', 'utf8', (err, data) => {
if (err) throw err;
console.log(data);
});
```
### Editar conteúdo desse arquivo.
```js
// file: updateFile.js
const fs = require('fs');
fs.writeFileSync('./meusArquivos/hello-world.txt','Aprendendo NodeJS com meus professores =]');
```
### Deletar arquivo.
```js
// file: deleteFile.js
const fs = require('fs');
fs.unlink('renameFile.txt', err => {
if(err) throw err;
console.log('Deletado com sucesso');
});
```
### Renomear o arquivo.
```js
// file: renameFile.js
const fs = require('fs');
fs.rename('./meusArquivos/hello-world.txt', './meusArquivos/helloWorld.txt', err => {
if (err) throw err;
})
```
## Desafio: Criar um servidor web de arquivos estáticos.
```js
'use strict';
const http = require('http'),
fs = require('fs'),
port = 3000;
// create directory for files.
try{
fs.accessSync('files', fs.F_OK);
}catch (e){
fs.mkdirSync('files');
}
http.createServer((req, res) => {
const path = `files${req.url}`;
try{
fs.accessSync(path, fs.R_OK);
if(fs.lstatSync(path).isDirectory()){
res.writeHeader(200, {"Content-Type": "text/html;charset=utf-8"});
try{
const indexPath = `${path}/index.html`;
res.write(fs.readFileSync(indexPath, 'utf-8'));
}catch(e){
const files = fs.readdirSync(path);
files.forEach(nome =>{
res.write(`<a href="${req.url}/${nome}">${nome}</a><br>`);
});
}
}else{
const typeFile = path.split(".");
switch(typeFile[typeFile.length-1]){
case 'css':
res.writeHeader(200, {"Content-Type": "text/css"});
break;
case 'html':
res.writeHeader(200, {"Content-Type": "text/html;charset=utf-8"});
break;
case 'jpg':
res.writeHeader(200, {"Content-Type": "image/jpeg"});
break;
case 'png':
res.writeHeader(200, {"Content-Type": "image/png"});
break;
}
res.write(fs.readFileSync(path));
}
} catch(e){
res.writeHeader(404, {"Content-Type": "text/html;charset=utf-8"});
res.write('Página não encontrada');
}
res.end();
}).listen(port, () => {
console.log(`Server rodando em localhost: ${port}`);
});
```
<b>Acessando servidor:</b>
<br>
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 05 - Exercício
**user:** [diegolopesdev](http://github.com.br/diegolopesdev)
**autor:** Diego Lopes
## Instale algum gerenciador de versão do Node.js e instale a versão mais atual como padrão, enquanto escrevo é a versão 5.4.0
Imagine que estou no Terminal e que vou instalar o gerenciador de versão do NodeJS chamado *n*.
```
sudo npm install n -g
```
Após instalar o *n*, eu escolho a versão que desejo instalar escrevendo a seguinte linha de código:
```
sudo n 5.5.0
```
ou, se houver necessidade de instalar a última versão:
```
sudo n latest
```
Eu estou usando o comando *sudo* porque estou no sistema operacional ubuntu, que é baseado no Debian, e que por padrão vem instalado. No Debian, por exemplo, o *sudo* não vem instalado por padrão, não havendo necessidade de usar a palavra *sudo*.
## Inicie um projeto novo para essa aula, com o `npm` e instale, salvando no `package.json`:
Terminal:
```
sudo mkdir maciota
cd maciota
npm init
```
Arquivo *package.json* sem dependências:
```js
{
"name": "maciota",
"version": "0.0.2",
"description": "Gerador da palavra Maciota",
"main": "app.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"keywords": [
"maciota",
"maciota",
"com",
"node"
],
"author": "Diego Lopes",
"license": "MIT"
}
```
No Terminal, eu escreverei o seguinte comando para instalar a dependência e salvar diretamente no meu arquivo *package.json*:
```
sudo npm install mongoose --save
```
Arquivo *package.json* com dependências instaladas.
```js
{
"name": "maciota",
"version": "0.0.2",
"description": "Gerador da palavra Maciota",
"main": "app.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"keywords": [
"maciota",
"maciota",
"com",
"node"
],
"author": "Diego Lopes",
"license": "MIT",
"dependencies": {
"mongoose": "^4.4.1"
}
}
```
## Crie e execute um script, via `npm`, que mostre uma mensagem no console com a global, que possui caminho para o diretório atual.
No arquivo *dir.js*, escreverei o seguinte comando:
```js
console.log("Meu diretório atual é:" + __dirname);
```
*package.json*
```js
{
"name": "maciota",
"version": "0.0.2",
"description": "Gerador da palavra Maciota",
"main": "app.js",
"scripts": {
"start": "node dir"
},
"keywords": [
"maciota",
"maciota",
"com",
"node"
],
"author": "Diego Lopes",
"license": "MIT",
"dependencies": {
"mongoose": "^4.4.1"
}
}
```
```
npm start
Meu diretório atual é:/home/diego/Estudos/NodeJS/05/maciota
```
## Cite 5 globais do Node.js e pelo menos 1 exemplo de cada.
*__dirname*
```js
console.log('Meu diretório atual é:' + __dirname);
```
*__filename*
```js
console.log('Meu arquivo se chama:' + __filename);
```
*process*
```js
process.on('exit', (code) => {
console.log('O processo terminou com o código: ', code);
});
```
*module*
```js
module.exports = (base, altura) => {
return {
area: function(){
return (base * altura)/2;
}
}
}
```
*setTimeout*
```js
setTimeout(() => {
console.log('Eu executei depois de 2 secundos. rs')
}, 2000)
```
## Explique como funciona e de um exemplo de `process`.
*Process* é um objeto global que é uma instância de *EventEmitter* responsável por manipular e transmitir eventos no Node. Com ele eu posso controlar quando um evento de saída *exit* acontece ou até mesmo quando ocorre alguma exceção *uncaughtException*.
Por ser um objeto global, não é necessário usar o *require*.
```js
var fs = require('fs');
process.on('beforeExit', () => {
console.log('Antes de fechar o processo, vamos ler o nosso arquivo package.json');
fs.open('package.json', (err, data) => {
if(err) throw err;
console.log(data);
});
});
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 05 - Exercício
autor: Bruno Lima da Silva
## 1. Instale algum gerenciador de versão do Node.js e instale a versão mais atual como padrão, enquanto escrevo é a versão 5.4.0
npm i n -g || npm i nvm -g
node -v
v6.9.1
## 2. Inicie um projeto novo para essa aula, com o npm e instale, salvando no package.json:
mkdir npm
cd npm
npm init
- 1 dependência local
npm i -S react
- 1 dependência local de desenvolvimento
npm i -D webpack
- 1 dependência local opcional
npm i -O colors
```js
cat package.json
{
"name": "npm",
"version": "1.0.0",
"description": "",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"author": "",
"license": "ISC",
"dependencies": {
"react": "^15.3.2"
},
"devDependencies": {
"webpack": "^1.13.3"
},
"optionalDependencies": {
"colors": "^1.1.2"
}
}
```
## 3. Crie e execute um script, via npm, que mostre uma mensagem no console com a global, que possui caminho para o diretório atual.
mkdir scrtip.js
```js
'use strict';
console.log (__dirname);
```
e no package.json
```js
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1",
"start": "node script.js"
},
```
## 4. Cite 5 globais do Node.js e pelo menos 1 exemplo de cada.
- dirname: O nome do diretório no qual o script em execução reside.
```js
console.log (__dirname);
> node script.js
/home/fsociety/be-mean-instagram/nodeJS/npm
```
- filename: O nome do arquivo do código que está sendo executado. Esse é o caminho absoluto resolvido desse arquivo de código.
```js
console.log (__filename);
> node script.js
/home/fsociety/be-mean-instagram/nodeJS/npm/script.js
```
- module: Uma referência ao módulo atual.
```js
console.log(module);
> node script.js
Module {
id: '.',
exports: {},
parent: null,
filename: '/home/fsociety/be-mean-instagram/nodeJS/npm/script.js',
loaded: false,
children: [],
paths:
[ '/home/fsociety/be-mean-instagram/nodeJS/npm/node_modules',
'/home/fsociety/be-mean-instagram/nodeJS/node_modules',
'/home/fsociety/be-mean-instagram/node_modules',
'/home/fsociety/node_modules',
'/home/node_modules',
'/node_modules' ] }
```
- buffer: usado para manipular dados binários
```js
var buff = new Buffer('Hello World!');
console.log(buff.toString());
```
- set time out: acrescenta um atraso na execução da função
```js
setTimeout(() => {
console.log("Após um segundo é executado");
}, 1000);
```
## 5. Explique como funciona e de um exemplo de process.
- Process é um objeto do NodeJS que fornece informações sobre o controle atual de processos do NodeJS. É uma instância de EventEmitter, ou seja, um emissor de eventos.
```js
// 'exit' é emitido quando um processo do NodeJS está a ser encerrado.
process.on ('exit', (code) => {
setTimeout (() => {
console.log('Estou saindo')
}, 0)
})
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 05 - Exercício
**User:** [matheusjkweber](https://github.com/matheusjkweber)
**Autor:** Matheus José Krumenauer Weber
**Date:** 1456875689947
## Instale algum gerenciador de versão do Node.js e instale a versão mais atual como padrão, enquanto escrevo é a versão 5.4.0
Instalei o nvm usando esse <a href="http://www.liquidweb.com/kb/how-to-install-nvm-node-version-manager-for-node-js-on-ubuntu-12-04-lts/">tutorial</a>.
```
nvm --version
0.31.0
```
## Inicie um projeto novo para essa aula, com o npm e instale, salvando no package.json:
```
npm init
This utility will walk you through creating a package.json file.
It only covers the most common items, and tries to guess sensible defaults.
See `npm help json` for definitive documentation on these fields
and exactly what they do.
Use `npm install <pkg> --save` afterwards to install a package and
save it as a dependency in the package.json file.
Press ^C at any time to quit.
name: (class5) pokemon-api
version: (1.0.0) 1.0.0
description: Api para Pokemons
entry point: (index.js)
test command:
git repository:
keywords: pokemons, api, nodejs, be-mean
author: Matheus Jose Krumenauer Weber
license: (ISC)
About to write to /home/matheus/Desktop/Desenvolvimento/workshop-be-mean/nodejs/class5/package.json:
{
"name": "pokemon-api",
"version": "1.0.0",
"description": "Api para Pokemons",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"keywords": [
"pokemons",
"api",
"nodejs",
"be-mean"
],
"author": "Matheus Jose Krumenauer Weber",
"license": "ISC"
}
```
Dependência Local
```
npm install --save mongoose
```
Dependência Local
```
npm install --save mongoose
pokemon-api@1.0.0 /home/matheus/Desktop/Desenvolvimento/workshop-be-mean/nodejs/class5
└─┬ mongoose@4.4.5
├── async@1.5.2
├── bson@0.4.21
├── hooks-fixed@1.1.0
├── kareem@1.0.1
├─┬ mongodb@2.1.6
│ ├── es6-promise@3.0.2
│ ├─┬ mongodb-core@1.3.1
│ │ └─┬ require_optional@1.0.0
│ │ ├── resolve-from@2.0.0
│ │ └── semver@5.1.0
│ └─┬ readable-stream@1.0.31
│ ├── core-util-is@1.0.2
│ ├── inherits@2.0.1
│ ├── isarray@0.0.1
│ └── string_decoder@0.10.31
├── mpath@0.2.1
├── mpromise@0.5.5
├─┬ mquery@1.7.0
│ ├── bluebird@2.9.26
│ ├── debug@2.2.0
│ └── sliced@0.0.5
├── ms@0.7.1
├── muri@1.1.0
├── regexp-clone@0.0.1
└── sliced@1.0.1
npm WARN pokemon-api@1.0.0 No repository field.
```
Dependência Local de Desenvolvimento
```
npm i --save-dev jasmine
pokemon-api@1.0.0 /home/matheus/Desktop/Desenvolvimento/workshop-be-mean/nodejs/class5
└─┬ jasmine@2.4.1
├── exit@0.1.2
├─┬ glob@3.2.11
│ └─┬ minimatch@0.3.0
│ ├── lru-cache@2.7.3
│ └── sigmund@1.0.1
└── jasmine-core@2.4.1
npm WARN pokemon-api@1.0.0 No repository field.
```
Dependência Local Opcional
```
npm i color --save-optional
pokemon-api@1.0.0 /home/matheus/Desktop/Desenvolvimento/workshop-be-mean/nodejs/class5
└─┬ color@0.11.1
├── color-convert@0.5.3
└─┬ color-string@0.3.0
└── color-name@1.1.1
npm WARN pokemon-api@1.0.0 No repository field.
matheus@Math:~/Desktop/Desenvolvimento/workshop-be-mean/nodejs/class5$
```
## Crie e execute um script, via 'npm', que mostre uma mensagem no console com a global, que possui caminho para o diretório atual.
- package.json
```js
"scripts":{
"roda": "node script.js"
},
```
- scripts.js
```js
console.log("Rodei");
```
- terminal
```
pokemon-api@1.0.0 roda /home/matheus/Desktop/Desenvolvimento/workshop-be-mean/nodejs/class5
> node script.js
Rodei
```
## Cite 5 globais do Node.js e pelo menos 1 exemplo de cada.
```
require - inclui um modulo no script.
__dirname - retorna o diretorio que o script esta sendo rodado.
__filename - retorna o arquivo que o script esta sendo rodado.
setTimeout - coloca um intervalo antes de rodar uma funcao.
setInterval - cria um loop de uma funcao.
```
```js
const http = require('http');
console.log(__dirname);
console.log(__filename);
setTimeout(function(){
console.log("Timeout");
});
setInterval(function(){
console.log("setInterval");
},200)
```
```
node global.js
/home/matheus/Desktop/Desenvolvimento/workshop-be-mean/nodejs/class5
/home/matheus/Desktop/Desenvolvimento/workshop-be-mean/nodejs/class5/global.js
Timeout
setInterval
setInterval
setInterval
setInterval
setInterval
```
## Explique como funciona e de um exemplo de process.
```js
É uma instância de EventEmitter, pode ser acessado de qualquer lugar, eles emitem eventos.
var EventEmitter = require('events').EventEmitter;
var emitter = new EventEmitter();
setInterval(function() {
console.log(process.memoryUsage().rss);
}, 1000);
node process.js
15593472
15859712
16130048
16130048
```
##Criar um arquivo
```js
/**
* Sync
*/
var fs = require('fs');
var wrtie = fs.writeFileSync('./hello.txt', "Hello world!");
/**
*Async
*/
fs.writeFile("./hello2.txt", "hello again", function(err, result){
if(err) throw err;
console.log(result);
});
var writeStream = fs.createWriteStream('./helloStream.txt', {defaultEnconding:'utf8'});
writeStream.write('Hello');
```
##Ler um arquivo
```js
var fs = require('fs')
fs.readFile('./meusArquivos/helloworld.txt', 'utf8', function(err,data){
if(err) throw err;
console.log(data);
});
var dataSync = fs.readFileSync('./meusArquivos/helloworld1.txt', {encoding:'utf8'});
console.log(dataSync);
```
##Editar conteúdo desse arquivo
```js
fs.writeFile("./meusArquivos/helloworld.txt", "hello edited", function(err, result){
if(err) throw err;
console.log(result);
});
```
##Deletar arquivo
```js
fs.unlink('./meusArquivos/helloworld.txt', function(err,data){
if(err) throw err;
console.log("Deletado.");
});
```
##Renomear o arquivo
```js
var fs = require('fs')
fs.rename('./eufuicriadocomnode/', './eufuirenomeadocomnode', function(err){
if(err) throw err;
});
```
#Desafio: Criar um servidor web de arquivos estáticos: .css, .html, .js e etc...
Index.html
```
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Be MEAN - Instagram</title>
<link rel="stylesheet" type="text/css" href="style.css" />
<script src="script.js"></script>
</head>
<body>
<h1>Be MEAN - Instagram - html </h1>
</body>
</html>
```
style.css
```
h1{
color:green;
}
```
script.js
```
alert("Funcionou!");
```
server.js
```js
var http = require('http')
, fs = require('fs')
, index=fs.readFileSync('index.html')
, style = fs.readFileSync('style.css')
, scripts = fs.readFileSync('script.js');
http.createServer(function(request,response){
console.log(request.url);
if (request.url == "/" || request.url=="/index.html"){
response.writeHead(200,{'Content-Type':'text/html'});
response.end(index);
}else if(request.url == "/style.css"){
response.writeHead(200,{'Content-Type':'text/css'});
response.end(style);
}else if(request.url == "/script.js"){
response.writeHead(200,{'Content-Type':'text/javascript'});
response.end(scripts);
}else{
response.writeHead(200, {'Content-Type': 'text/html; charset=utf-8'});
response.write('<h1>404 - O arquivo não existe</h1>');
}
}).listen(3000,function(){
console.log('Servidor rodando em localhost:3000');
})
```
Resultado:
<img src="https://raw.githubusercontent.com/matheusjkweber/aux/master/Screenshot.from.2016-03-02.21.15.39.png">
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 05 - Exercício
**User:** ronal2do
**Author:** Ronaldo Lima
**Date:** 1468036239552
##### [Exercício-01](#instale-algum-gerenciador-de-vers%C3%A3o-do-nodejs-e-instale-a-vers%C3%A3o-mais-atual-como-padr%C3%A3o-enquanto-escrevo-%C3%A9-a-vers%C3%A3o-540)
##### [Exercício-02](#inicie-um-projeto-novo-para-essa-aula-com-o-npm-e-instale-salvando-no-packagejson)
##### [Exercício-03](#crie-e-execute-um-script-via-npm-que-mostre-uma-mensagem-no-console-com-a-global-que-possui-caminho-para-o-diret%C3%B3rio-atual)
##### [Exercício-04](#cite-5-globais-do-nodejs-e-pelo-menos-1-exemplo-de-cada)
##### [Exercício-05](#explique-como-funciona-e-de-um-exemplo-de-process)
## [Parte 02 ](#nodejs---aula-05-parte-02---exerc%C3%ADcio)
## Instale algum gerenciador de versão do Node.js e instale a versão mais atual como padrão, enquanto escrevo é a versão 5.4.0
```
npm install -g webpack
/usr/local/bin/webpack -> /usr/local/lib/node_modules/webpack/bin/webpack.js
/usr/local/lib
└─┬ webpack@1.13.1
├─┬ node-libs-browser@0.5.3
│ └── events@1.1.1
├── uglify-js@2.6.4
└─┬ watchpack@0.2.9
└─┬ chokidar@1.6.0
├─┬ is-binary-path@1.0.1
│ └── binary-extensions@1.5.0
└─┬ readdirp@2.1.0
├── minimatch@3.0.2
└── set-immediate-shim@1.0.1
```
```
npm install -g webpack@2.1.0-beta.15
/usr/local/bin/webpack -> /usr/local/lib/node_modules/webpack/bin/webpack.js
- amdefine@1.0.0 node_modules/webpack/node_modules/amdefine
- etc ...
```
## Inicie um projeto novo para essa aula, com o `npm` e instale, salvando no `package.json`:
```js
sh-3.2# cat package.json
{
"name": "aula05",
"version": "0.0.1",
"description": "Exercício proposto em aula",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"keywords": [
"aula05",
"test"
],
"author": "ronal2do",
"license": "MIT"
}
```
* Dependência local
```
npm install --save react
```
* Dependência local
```
npm install --save-dev jasmine
```
* Dependência local
```
npm install --save-optional colors
```
Package.json
```js
sh-3.2# cat package.json
{
"name": "aula05",
"version": "0.0.1",
"description": "Exercício proposto em aula",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"keywords": [
"aula05",
"test"
],
"author": "ronal2do",
"license": "MIT",
"dependencies": {
"react": "^15.2.1"
},
"devDependencies": {
"mocha": "^2.5.3"
},
"optionalDependencies": {
"colors": "^1.1.2"
}
}
```
## Crie e execute um script, via `npm`, que mostre uma mensagem no console com a global, que possui caminho para o diretório atual.
```js
sh-3.2# cat package.json
{
"name": "aula05",
"version": "0.0.1",
"description": "Exercício proposto em aula",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1",
"dir": "node dir.js"
},
"keywords": [
"aula05",
"test"
],
"author": "ronal2do",
"license": "MIT",
"dependencies": {
"gulp": "^3.9.1",
"react": "^15.2.1"
},
"devDependencies": {
"jasmine": "^2.4.1",
"mocha": "^2.5.3"
},
"optionalDependencies": {
"colors": "^1.1.2"
}
}
```
```js
sh-3.2# cat dir.js
console.log("Meu diretório atual é:" + __dirname);
```
```js
sh-3.2# npm run dir
> aula05@0.0.1 dir /Users/ronaldolima/testes/npm
> node dir.js
Meu diretório atual é:/Users/ronaldolima/testes/npm
```
## Cite 5 globais do Node.js e pelo menos 1 exemplo de cada.
*__dirname*
```js
console.log(__dirname);
```
*__filename*
```js
console.log(__filename);
```
*Buffer*
```js
const buff = new Buffer('Sou um buffer');
console.log(buff.toString());
```
*setTimeout*
```js
setTimeout(()=>{
console.log('atrasado');
}, 3000);
```
*console*
```js
console.log('Qualquer coisa');
```
## Explique como funciona e de um exemplo de `process`.
Process é um objeto global e é uma instância de `EventEmiter`.
```js
'use strict';
process.nextTick(() => {
console.log('Eu sou um async');
});
```
# Node.js - Aula 05 parte 02 - Exercício
## File System
### Criar um arquivo.
```js
'use strict';
const fs = require('fs');
fs.writeFile("./arquivo.txt","Salve Loko, fui gerado no Node", (err) => {
if (err) throw err;
console.log('File created!');
});
```
Saída:
```
sh-3.2# node create.js && ls
File created!
arquivo.txt create.js
```
### Ler um arquivo.
```js
'use strict';
const fs = require('fs');
fs.readFile('mensagem.txt', (err, data) => {
if (err) throw err;
console.log(data.toString());
});
```
Saída:
```
sh-3.2# node read.js && ls
Salve Loko, fui gerado no Node
arquivo.txt create.js read.js
```
### Editar conteúdo desse arquivo.
```js
'use strict';
const fs = require('fs');
fs.readFile('mensagem.txt', 'utf-8', (err, data) => {
if (err) throw err;
const content = data + "\n Sou um novo conteúdo adicionado ao arquivo.";
fs.writeFile('mensagem.txt', content, 'utf-8', (err) => {
if (err) throw err;
console.log(content);
});
});
```
Saída:
```js
sh-3.2# node update.js && ls
Salve Loko, fui gerado no Node
Salve Loko, fui gerado no Node Editado.
arquivo.txt create.js read.js update.js
```
### Deletar arquivo.
```js
'use strict';
const fs = require('fs');
fs.unlink('mensagem.txt', (err) => {
if (err) throw err;
console.log('Arquivo deletado com sucesso.');
});
```
Saída:
```
sh-3.2# node delete.js && ls
File destroyed!
create.js delete.js read.js update.js
```
### Renomear o arquivo.
```js
'use strict';
const fs = require('fs');
fs.rename("./arquivo.txt", 'arquivo-renomeado.txt', (err, data) => {
if (err) throw err;
console.log('File renamed!');
});
```
Saída:
```
sh-3.2# node rename.js && ls
arquivo-renomeado.txt delete.js rename.js
create.js read.js update.js
```
# Desafio: Criar um servidor web de arquivos estáticos (CSS, HTML, JS).
app.js
```js
'use strict';
let http = require('http')
, fs = require('fs');
http.createServer((req, res)=>{
if( req.url!=="/" ) {
let url = "." + req.url;
fs.readFile(url, (err, data)=>{
if(err) {
res.writeHead(404, {'Content-Type': 'text/html'});
res.write(' <link rel="stylesheet" href="app.css">');
res.write('<div class="Container"><h1>404</h1></div>');
res.end();
} else {
let type = 'text/' + url.match(/[^\.]+$/g);
res.writeHead(200, {'Content-Type': type});
res.write(data);
res.end();
}
});
} else {
res.writeHead(200, {'Content-Type': 'text/html'});
let html = fs.readFileSync('./index.html', 'utf8');
res.write(html);
res.end();
}
}).listen(3000, ()=>{
console.log('Aplicação rodando em localhost:3000')
});
```
### Acessando HTML
### Pagina Não Encontrada.
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 05 - Exercício
**User:** [Cerezini](https://github.com/Cerezini)
**Autor:** Mateus Cerezini Gomes
## Instale algum gerenciador de versão do Node.js e instale a versão mais atual como padrão, enquanto escrevo é a versão 5.4.0
```shell
> curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.31.0/install.sh | bash
> nvm install node
> node -v
v5.9.0
> npm -v
3.7.3
```
## Inicie um projeto novo para essa aula, com o `npm` e instale, salvando no `package.json`:
- 1 dependência local
- 1 dependência local de desenvolvimento
- 1 dependência local opcional
```shell
> mkdir aula5
> cd aula5
> npm init
> npm i -S moment
> npm i -D react
> npm i -O q
> cat package.json
{
"name": "aula5",
"version": "0.0.1",
"description": "Projeto teste aula 5",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"keywords": [
"nodejs",
"aula5",
"teste"
],
"author": "Cerezini",
"license": "ISC",
"dependencies": {
"moment": "^2.12.0"
},
"devDependencies": {
"react": "^0.14.7"
},
"optionalDependencies": {
"q": "^1.4.1"
}
}
```
## Crie e execute um script, via `npm`, que mostre uma mensagem no console com a global, que possui caminho para o diretório atual.
```shell
> echo "console.log(__dirname);" > script.js
```
Modifica o arquivo packages.json
```json
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1",
"dir": "node script.js"
}
```
```shell
> npm run dir
~/Documentos/Curso/testes/nodejs/aula5
```
## Cite 5 globais do Node.js e pelo menos 1 exemplo de cada.
1. console
2. \__dirname
3. \__filename
4. process
5. require
```js
//1
console.log('potato bread');
//2 e 3
console.log(__dirname);
console.log(__filename);
//4
console.log('Program PID: ', process.pid);
//5
const http = require('http');
```
## Explique como funciona e de um exemplo de `process`.
Process é um objeto global que contém informações referentes ao processo nodejs executando no SO.
```js
//Mostrar PID
>console.log('Program PID: ', process.pid);
Program PID: 5039
//Mostrar caminho do executável node
>console.log('Executable path: ', process.execPath);
Executable path: ~/.nvm/versions/node/v5.9.0/bin/node
//Finalizar processo
>process.exit(0);
```
## Criar um arquivo
```js
const fs = require('fs');
fs.writeFile('potato.txt', 'Um pão de batata, calzone, essas coisas.', 'utf8', (err) => {
if (err) throw err;
console.log('Arquivo criado!');
});
Arquivo criado!
```
## Ler um arquivo
```js
fs.readFile('potato.txt', 'utf8', (err, data) => {
if (err) throw err;
console.log(data);
});
Um pão de batata, calzone, essas coisas.
```
## Editar conteúdo desse arquivo
```js
fs.readFile('potato.txt', 'utf8', (err, data) => {
if (err) throw err;
data += ' O meu pai? Romero Brito? Guarapari? Búzios, minha arte?'
fs.writeFile('potato.txt', data, 'utf8', (err) => {
if (err) throw err;
console.log('Arquivo editado!');
});
});
Arquivo editado!
```
## Deletar arquivo
```js
fs.unlink('calzone.txt', (err) => {
if (err) throw err;
console.log('Arquivo deletado!');
});
Arquivo deletado!
```
## Renomear o arquivo
```js
fs.rename('potato.txt', 'calzone.txt', (err) => {
if (err) throw err;
console.log('Arquivo renomeado!');
});
Arquivo renomeado!
```
## Desafio: Criar um servidor web de arquivos estáticos: .css, .html, .js e etc... UTILIZANDO SOMENTE `fs` E `http`
```js
'use strict';
const http = require('http'),
fs = require('fs'),
path = require('path');
http.createServer(function(req, res){
let file = path.basename(req.url),
ext = path.extname(file),
contentType = '';
switch (ext) {
case 'html':
contentType = 'text/html';
break;
case 'css':
contentType = 'text/css';
break;
case 'js':
contentType = 'application/javascript';
break;
case 'png':
contentType = 'image/jpeg';
break;
default:
contentType = 'text/html';
break;
}
fs.readFile(file, 'utf8', (err, data) => {
if (err) {
res.writeHead(500, {"Content-Type": "text/html"});
res.end(err.toString());
} else {
res.writeHead(200, {"Content-Type": contentType});
res.end(data);
}
});
}).listen(3000, function(){
console.log('Servidor rodando em localhost:3000');
});
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 05 - Exercício
**user:** [fauker](http://github.com/fauker)
**autor:** LUCAS DA SILVA MOREIRA
## Instale algum gerenciador de versão do Node.js e instale a versão mais atual como padrão, enquanto escrevo é a versão 5.4.0
```
lucasmoreira@faukbook ~ nvm install 6.0.0
######################################################################## 100,0%
Checksums empty
Now using node v6.0.0
lucasmoreira@faukbook ~ node -v
v6.0.0
lucasmoreira@faukbook ~ nvm current
v6.0.0
lucasmoreira@faukbook ~
```
## Inicie um projeto novo para essa aula, com o `npm` e instale, salvando no `package.json`:
```
npm init
```
- 1 dependência local
```
npm install --save angularjs
```
- 1 dependência local de desenvolvimento
```
npm install --save-dev mocha
```
- 1 dependência local opcional
```
npm install --save-optional restangular
```
```
cat package.json
{
"name": "be-mean-instagram-nodejs",
"version": "1.0.0",
"description": "Guia de referência do conteúdo ministrado no módulo **Nodejs** do curso gratuíto [*Construa seu Instagram com MEAN*](http://dagora.net/be-mean/) da [Webschool.io](https://github.com/Webschool-io/)",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"repository": {
"type": "git",
"url": "git+https://github.com/fauker/be-mean-instagram-nodejs.git"
},
"author": "",
"license": "ISC",
"bugs": {
"url": "https://github.com/fauker/be-mean-instagram-nodejs/issues"
},
"homepage": "https://github.com/fauker/be-mean-instagram-nodejs#readme",
"dependencies": {
"angularjs": "0.0.1"
},
"devDependencies": {
"mocha": "^2.4.5"
},
"optionalDependencies": {
"restangular": "^1.5.2"
}
}
```
## Crie e execute um script, via `npm`, que mostre uma mensagem no console com a global, que possui caminho para o diretório atual.
```
script.js -> console.log
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1",
"dir": "node script.js"
},
npm run dir
> be-mean-instagram-nodejs@1.0.0 dir /Users/lucasmoreira/Documents/dev/projects/Be MEAN Instagram /be-mean-instagram-nodejs
> node script.js
```
## Cite 5 globais do Node.js e pelo menos 1 exemplo de cada.
```
//1
console.log(__dirname);
//2
console.log(__filename);
//3
var buffer = new Buffer('Oie');
console.log(buffer.toString());
//4
console.log(process.pid)
//5
var express = require('express');
```
## Explique como funciona e de um exemplo de `process`.
O `process` é um objeto global do `node` e pode ser acessado de qualquer
lugar. É uma instância do `EventEmitter`.
```
process.title
'node'
```
## Criar um arquivo
```
var fs = require('fs');
var write = fs.writeFileSync('file.txt', 'Oieee!!!!');
ls
createFile.js
file.txt
```
## Ler um arquivo
```
var fs = require('fs');
fs.readFile('file.txt', 'utf-8', function(err, data) {
if (err) throw err;
console.log(data);
});
node readFile.js
Oieee!!!!
```
## Editar conteúdo desse arquivo
```
var fs = require('fs');
fs.readFile('file.txt', 'utf-8', function(err, data) {
if (err) throw err;
console.log('conteúdo antigo: ' + data);
var novoConteudo = 'Novo conteúdo';
fs.writeFileSync('file.txt', novoConteudo);
});
node editFile.js
conteúdo antigo: Oieee!!!!
cat file.txt
Novo conteúdo%
```
## Renomear o arquivo
```
var fs = require('fs');
fs.rename('file.txt', 'fileAlterado.txt', function(err, data) {
if (err) throw err;
console.log(data);
});
node renameFile.js
undefined
ls
createFile.js readFile.js
editFile.js renameFile.js
fileAlterado.txt
```
## Deletar arquivo
```
var fs = require('fs');
fs.unlink('fileAlterado.txt', function(err) {
if (err) throw err;
console.log('Sucesso ao remover o arquivo fileAlterado.txt');
});
node deleteFile.js
Sucesso ao remover o arquivo fileAlterado.txt
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 05 - Exercício
**user:** [fernandobd42](https://github.com/fernandobd42)
**autor:** Fernando Lucas
## 1 - Instale algum gerenciador de versão do Node.js e instale a versão mais atual como padrão, enquanto escrevo é a versão 5.4.0
**Instalando NVM**
```
wget -qO- https://raw.githubusercontent.com/creationix/nvm/v0.32.1/install.sh | bash
```
**Instalando versão atual do Node**
```
➜ Node_BeMean nvm install node
v7.0.0 is already installed.
Now using node v7.0.0
```
## 2 - Inicie um projeto novo para essa aula, com o `npm` e instale, salvando no `package.json`:
```
➜ Node_BeMean mkdir New_Project
➜ Node_BeMean cd New_Project
➜ New_Project npm init
This utility will walk you through creating a package.json file.
It only covers the most common items, and tries to guess sensible defaults.
See `npm help json` for definitive documentation on these fields
and exactly what they do.
Use `npm install <pkg> --save` afterwards to install a package and
save it as a dependency in the package.json file.
Press ^C at any time to quit.
name: (New_Project) New_Project
Sorry, name can no longer contain capital letters.
name: (New_Project) new_project
version: (1.0.0)
description: project nodejs-bemean
entry point: (index.js)
test command:
git repository:
keywords:
author: Fernando Lucas
license: (ISC)
About to write to /home/fernando/Documentos/Node_BeMean/New_Project/package.json:
{
"name": "new_project",
"version": "1.0.0",
"description": "project nodejs-bemean",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"author": "Fernando Lucas",
"license": "ISC"
}
Is this ok? (yes)
➜ New_Project ls
package.json
```
**Dependência Local**
```
npm i --save bower
```
**Dependência de desenvolvimento**
```
npm i --save-dev gulp
```
**Dependência opcional**
```
npm i --save-optional colors
```
**package.json**
```
➜ New_Project cat package.json
{
"name": "new_project",
"version": "1.0.0",
"description": "project nodejs-bemean",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"author": "Fernando Lucas",
"license": "ISC",
"dependencies": {
"bower": "^1.8.0"
},
"devDependencies": {
"gulp": "^3.9.1"
},
"optionalDependencies": {
"colors": "^1.1.2"
}
}
```
## - Crie e execute um script, via `npm`, que mostre uma mensagem no console com a global, que possui caminho para o diretório atual.
**Cógido arquiro dir.js**
```
console.log(__dirname);
```
**Código package.json**
```
{
"name": "new_project",
"version": "1.0.0",
"description": "project nodejs-bemean",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1",
"dirpath": "node dir.js"
},
"author": "Fernando Lucas",
"license": "ISC",
"dependencies": {
"bower": "^1.8.0"
},
"devDependencies": {
"gulp": "^3.9.1"
},
"optionalDependencies": {
"colors": "^1.1.2"
}
}
```
**Código para mostrar o caminho**
```
➜ New_Project npm run-script dirpath
> new_project@1.0.0 dirname /home/fernando/Documentos/Node_BeMean/New_Project
> node dir.js
/home/fernando/Documentos/Node_BeMean/New_Project
```
## Cite 5 globais do Node.js e pelo menos 1 exemplo de cada.
**console -> exibe mensagem no console**
```
console.log('Printando');
```
**__filename -> exibe o caminho do arquivo que está sendo executado**
```
console.log(__filename)
```
**__dirname -> exibe o caminho do diretório em que o arquivo está inserido**
```
console.log(__dirname)
```
**require() -> importa um módulo do node**
```
require('http')
```
**setTimeout() -> define uma latência para exibir/executar determinada instrução**
```
setTimeout(() => {
console.log('Latência de 5 segundos para exibir esta mensagem');
}, 5000);
```
## Explique como funciona e de um exemplo de `process`.
Process é uma instância do EventEmitter, é uma variável global que emite eventos.
**exibe caminho do node**
```
console.log(process.execPath);
```
**exibe o diretorio atual**
```
console.log(process.cwd());
```
## Criar um arquivo
```
const fs = require('fs');
fs.writeFile('./file.txt','Criando arquivo', (err) => {
if (err) throw err;
console.log('Arquivo Criado!');
})
```
## Ler um arquivo
```
const fs = require('fs');
fs.readFile('./file.txt', (err, data) => {
if (err) throw err;
console.log(data.toString());
});
```
## Editar conteúdo desse arquivo
```
const fs = require('fs');
fs.readFile('./file.txt', (err, data) => {
data += ' e Editando';
fs.writeFile('./file.txt', data, (err) => {
if (err) throw err;
})
console.log(data.toString());
});
```
## Renomear o arquivo
```
const fs = require('fs');
fs.rename('./file.txt', './file_renamed.txt', (err, data) => {
if (err) throw err;
console.log('Arquivo renomeado com sucesso.');
});
```
## Deletar arquivo
```
const fs = require('fs');
fs.unlink('./file_renamed.txt', (err) => {
if (err) throw err;
console.log('Arquivo deletado com sucesso.');
});
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 05 - Exercício
**user:** [FranciscoValerio](https://github.com/FranciscoValerio)
**autor:** Francisco Henrique Ruiz Valério
## Instale algum gerenciador de versão do Node.js e instale a versão mais atual como padrão, enquanto escrevo é a versão 5.4.0
```
PS C:\Users\franc> npm -v
3.3.12
PS C:\Users\franc> node -v
v5.4.1
```
## Inicie um projeto novo para essa aula, com o `npm` e instale, salvando no `package.json`:
* 1 dependência local
* 1 dependência local de desenvolvimento
* 1 dependência local opcional
```
PS C:\Be-Mean\NodeJS\arquivos-api> npm i --save mongoose
PS C:\Be-Mean\NodeJS\arquivos-api> npm i --save-dev colors
PS C:\Be-Mean\NodeJS\arquivos-api> npm i --save-optional colors
PS C:\Be-Mean\NodeJS\arquivos-api> cat .\package.json
{
"name": "arquivos-api",
"version": "0.0.1",
"description": "API que fornece arquivos",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"keywords": [
"arquivos",
"css",
"html",
"js"
],
"author": "FranciscoValerio",
"license": "WTFPL",
"dependencies": {
"mongoose": "^4.3.6"
},
"devDependencies": {
"jasmine": "^2.4.1"
},
"optionalDependencies": {
"colors": "^1.1.2"
}
}
```
## Crie e execute um script, via `npm`, que mostre uma mensagem no console com a global, que possui caminho para o diretório atual.
```
//package.json
"scripts": {
"roda": "node script.js"
}
//Arquivo script.js
console.log( __dirname );
PS C:\Be-Mean\NodeJS\arquivos-api> npm run roda
> arquivos-api@0.0.1 roda C:\Be-Mean\NodeJS\arquivos-api
> node script.js
C:\Be-Mean\NodeJS\arquivos-api
```
## Cite 5 globais do Node.js e pelo menos 1 exemplo de cada.
**require:** Usamos quando queremos chamar um módulos do NodeJS.
```JS
require('http');
```
**__dirname:** Usada para obter o caminho do diretório atual.
```JS
console.log(__dirname);
```
**__filename:** Usada quando queremos obter o caminho do arquivo atual.
```JS
console.log(__filename);
```
**Buffer:** Usada para inserir algo no buffer
```JS
var buffer = new Buffer('I am Buffer!');
console.log(buffer.toString());
```
**process.pid:** Usado quando queremos obter o id do processo sendo executado na máquina.
```JS
console.log(process.pid);
```
## Explique como funciona e de um exemplo de `process`.
O objeto process é um objeto global e pode ser acessado de qualquer lugar. É uma instância de EventEmitter. Normalmente é utilizado quando queremos executar algo quando algum evento ocorrer.
```JS
//Um exemplo que registra cada rejeição não processada para o console
process.on('unhandledRejection', (reason, p) => {
console.log("Rejeição Unhandled em: Promise", p, "razão:", reason);
});
// e aqui um exemplo que irá chamar o unhandledRejection
somePromise.then((response) => {
return reportToUser(JSON.parse(response));
});
```
##Desafio: Criar um servidor web de arquivos estáticos: .css, .html, .js e etc...
Os arquivos podem ser encontrados aqui:
(https://github.com/FranciscoValerio/server-files)
**servidor.js:**
```
'use strict';
const http = require( 'http' ),
fs = require('fs'),
port = 3000;
try{
fs.accessSync( 'arquivos', fs.F_OK );
}catch (e){
fs.mkdirSync( 'arquivos' );
}
http.createServer( function( req, res ){
var path = 'arquivos' + req.url;
try{
fs.accessSync( path, fs.R_OK );
if( fs.lstatSync( path ).isDirectory() ){
res.writeHeader( 200, { "Content-Type": "text/html;charset=utf-8" } );
try{
var indexPath = path + '/index.html';
res.write( fs.readFileSync( indexPath, 'utf-8' ) );
}catch(e){
var files = fs.readdirSync(path);
files.forEach(file =>{
res.write('<a href="' + req.url + '/' + file + '">' + file + '</a><br>' );
});
}
}else{
var typeFile = path.split(".");
switch(typeFile[typeFile.length-1]){
case 'css':
res.writeHeader(200, {"Content-Type": "text/css"});
break;
case 'html':
res.writeHeader(200, {"Content-Type": "text/html;charset=utf-8"});
break;
case 'jpg':
res.writeHeader(200, {"Content-Type": "image/jpeg"});
break;
case 'png':
res.writeHeader(200, {"Content-Type": "image/png"});
break;
case 'gif':
res.writeHeader(200, {"Content-Type": "image/gif"});
break;
}
res.write(fs.readFileSync(path));
}
} catch(e){
res.writeHeader(404, {"Content-Type": "text/html;charset=utf-8"});
res.write( fs.readFileSync( 'arquivos/not_found.html' ) );
}
res.end();
}).listen(port, () => {
console.log('Waiting in port: ' + port );
});
```
**not_found.js:**
```HTML
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Servidor de arquivos - Desafio -</title>
<style>
body {
background: url('/img/beer.jpg');
background-repeat: no-repeat;
background-size: 100%;
}
h1 {
font-size: 140px;
}
h2 {
font-size: 40px;
}
</style>
</head>
<body>
<h1>404 :(</h1>
<h2>
Beer not found...
<br>
Ops...
<br>
Page not found...
</h2>
</body>
</html>
```
**Rodando:**
**Home:**
<br>
**Arquivos JS:**
<br>
**404 - Not found:**
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 05 - Exercício
**user:** [ednilsonamaral](https://github.com/ednilsonamaral)
**autor:** Ednilson Amaral
## Instale algum gerenciador de versão do Node.js e instale a versão mais atual como padrão, enquanto escrevo é a versão 5.4.0
`node -v`
Saída:
```
ednilson@EDNILSON-NB:~$ node -v
v5.5.0
```
`npm -v`
Saída:
```
ednilson@EDNILSON-NB:~$ npm -v
3.3.12
```
## Inicie um projeto novo para essa aula, com o `npm` e instale, salvando no `package.json`:
```
ednilson@EDNILSON-NB:/var/www/be-mean-instagram-nodejs/exercicios05$ cat package.json
{
"name": "aula05",
"version": "1.0.0",
"description": "Exercícios da Aula 05 de NodeJS do curso Be MEAN",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"keywords": [
"node",
"mean",
"webschool"
],
"author": "Ednilson Amaral",
"license": "WTFPL"
}
```
### 1 dependência local; 1 dependência local de desenvolvimento; 1 dependência local opcional
`npm install -S gulp`
`npm install --save-dev jasmine`
`npm install -O moongose`
Arquivo `package.json`:
```
ednilson@EDNILSON-NB:/var/www/be-mean-instagram-nodejs/exercicios05$ cat package.json
{
"name": "aula05",
"version": "1.0.0",
"description": "Exercícios da Aula 05 de NodeJS do curso Be MEAN",
"main": "index.js",
"scripts": {
"executa": "node script.js"
},
"keywords": [
"node",
"mean",
"webschool"
],
"author": "Ednilson Amaral",
"license": "WTFPL",
"dependencies": {
"gulp": "^3.9.0"
},
"devDependencies": {
"jasmine": "^2.4.1"
},
"optionalDependencies": {
"mongoose": "^4.3.7"
}
}
```
## Crie e execute um script, via `npm`, que mostre uma mensagem no console com a global, que possui caminho para o diretório atual.
```
ednilson@EDNILSON-NB:/var/www/be-mean-instagram-nodejs/exercicios05$ npm run executa
> aula05@1.0.0 executa /var/www/be-mean-instagram-nodejs/exercicios05
> node script.js
O diretório atual é listado abaixo:
/var/www/be-mean-instagram-nodejs/exercicios05
```
## Cite 5 globais do Node.js e pelo menos 1 exemplo de cada.
### `__dirname`
Ele mostra o caminho do diretório em que o script atual se encontra. Exemplo:
Em nosso arquivo JS temos:
```js
//script.js
console.log(__dirname);
```
Executando, temos:
```
//node
ednilson@EDNILSON-NB:/var/www/be-mean-instagram-nodejs$ node script.js
/var/www/be-mean-instagram-nodejs
```
### `__filename`
Ele mostra o caminho do diretório do arquivo que está sendo executado se encontra.
Em nosso arquivo JS temos:
```js
console.log(__filename);
```
Executando, temos:
```
ednilson@EDNILSON-NB:/var/www/be-mean-instagram-nodejs$ node script.js
/var/www/be-mean-instagram-nodejs/script.js
```
### `setTimeout()`
É uma função global usada para chamar uma função callback após X milissegundos.
Em nosso arquivo JS temos:
```js
function mostra(){
console.log("Hello, world!");
}
setTimeout(mostra, 3000);
```
Executando, temos:
```
ednilson@EDNILSON-NB:/var/www/be-mean-instagram-nodejs$ node script.js
Hello, world, após 3 segundos!
```
### `clearTimeout()`
Também é uma função global, utilizada para párar o cronômetro que foi criada no `setTimeout()`.
Em nosso arquivo JS temos:
```js
function printHello(){
console.log( "Hello, World, após 2 segundos e depois dá um CLEAR!");
}
var t = setTimeout(printHello, 5000);
clearTimeout(t);
```
### `setInterval()`
É uma função global utilizada para executar uma função callback repetidamente após os milissegundos declarados. Para mátar o serviço devemos declarar um `clearInterval()` na função `setTimeout()`.
Em nosso arquivo JS temos:
```js
const time = setInterval(() => console.log("Hello, again and again and again!"), 1000);
setTimeout(() => {
clearInterval(time);
}, 5000);
```
Executando, temos:
```
ednilson@EDNILSON-NB:/var/www/be-mean-instagram-nodejs$ node script.js
Hello, again and again and again!
Hello, again and again and again!
Hello, again and again and again!
Hello, again and again and again!
ednilson@EDNILSON-NB:/var/www/be-mean-instagram-nodejs$
```
## Explique como funciona e de um exemplo de `process`.
É um objeto global que pode ser acessado de qualquer lugar e é uma instância de **EventEmitter**, ou seja, eles emitem eventos. Ele é útil para podermos identificar algumas informações sobre o ambiente de tempo de execução de um aplicativo, os argumentos passados, o diretório atual, etc.
No exemplo abaixo, vemos o processo *exit* do evento, que é emitido quando está prestes a sair. Assim que todos as funções dentro do processo estiverem terminadas, ele vai sair, ou seja, *exit*.
```js
process.on('exit', function(code) {
setTimeout(function() {
console.log("Está rodando essa bagaça!");
}, 0);
console.log('Sobre esse código:', code);
});
console.log("Código finalizado, vlw flw!");
```
## Criar um arquivo
Arquivo `create.js`:
```js
//criando o arquivo de forma async
var fs = require('fs');
fs.writeFile("./arquivo.txt", "Hello, world!", function(err, result){
if (err) throw err;
console.log(result);
});
```
Saída no terminal:
```
ednilson@EDNILSON-NB:/var/www/be-mean-instagram-nodejs/fs$ node create.js
undefined
ednilson@EDNILSON-NB:/var/www/be-mean-instagram-nodejs/fs$ ls
arquivo.txt create.js
ednilson@EDNILSON-NB:/var/www/be-mean-instagram-nodejs/fs$ cat arquivo.txt
Hello, world!
```
## Ler um arquivo
Arquivo `read.js`:
```js
//lendo o arquivo de forma async
var fs = require('fs');
fs.readFile('arquivo.txt', 'utf-8', function (err, data){
if (err) throw err;
console.log(data);
});
```
Saída no terminal:
```
ednilson@EDNILSON-NB:/var/www/be-mean-instagram-nodejs/fs$ node read.js
Hello, world!
```
## Editar conteúdo desse arquivo
Arquivo `edit.js`:
```js
//editando o arquivo de forma async
//primeiro, leio o arquivo; se não der erro na leitura, então acrescento uma nova linha com texto
var fs = require('fs');
fs.readFile('arquivo.txt', 'utf-8', function (err, data) {
if (err) throw err;
var update = data + "\nNovo conteúdo no arquivo!";
fs.writeFile('arquivo.txt', update, 'utf-8', function (err){
if (err) throw err;
console.log(update);
});
});
```
Saída no terminal:
```
ednilson@EDNILSON-NB:/var/www/be-mean-instagram-nodejs/fs$ node edit.js
Hello, world!
Novo conteúdo no arquivo!
```
## Deletar arquivo
Arquivo `delete.js`:
```js
//deletando o arquivo de forma async
var fs = require('fs');
fs.unlink('arquivo.txt', function (err){
if (err) throw err;
});
```
Saída no terminal:
```
ednilson@EDNILSON-NB:/var/www/be-mean-instagram-nodejs/fs$ node delete.js
ednilson@EDNILSON-NB:/var/www/be-mean-instagram-nodejs/fs$
```
## Renomear o arquivo
Arquivo `rename.js`:
```js
//renomeando arquivo de forma async
var fs = require('fs');
fs.rename('arquivo.txt', 'arquivoRenomeado.txt', function (err, data) {
if (err) throw err;
});
```
Saída no terminal:
```
ednilson@EDNILSON-NB:/var/www/be-mean-instagram-nodejs/fs$ node rename.js
/var/www/be-mean-instagram-nodejs/fs/rename.js:5
if (err) throw err;
^
Error: ENOENT: no such file or directory, rename 'arquivo.txt' -> 'arquivoRenomeado.txt'
at Error (native)
```
Deu esse erro aí porque o arquivo foi deletado, né! Hehehe'
## Desafio
Arquivo `server.js`:
```js
var http = require('http');
var fs = require('fs');
http.createServer(function (request, response){
var path = 'desafio'+ request.url;
//verificando se ele encontra o diretorio, caso não encontre, criar
try{
fs.accessSync('desafio', fs.F_OK);
} catch (e){
fs.mkdirSync('desafio');
}
try{
fs.accessSync(path, fs.R_OK);
if(fs.lstatSync(path).isDirectory()){
response.writeHeader(200, {"Content-Type": "text/html"});
try{
var indexPath = path+'/index.html';
response.write(fs.readFileSync(indexPath, 'utf-8'));
}catch(e){
var dir = fs.readdirSync(path);
dir.forEach(nome =>{
response.write('<a href="'+ request.url +'/'+ nome +'">'+ nome +'</a><br>');
});
}
} else {
var typeFile = path.split(".");
switch(typeFile[typeFile.length-1]){
case 'css':
response.writeHead(200, {"Content-Type": "text/css"});
break;
case 'html':
response.writeHead(200, {"Content-Type": "text/html"});
break;
case 'jpg':
response.writeHead(200, {"Content-Type": "image/jpeg"});
break;
case 'gif':
response.writeHead(200, {"Content-Type": "image/gif"});
break;
}
response.write(fs.readFileSync(path));
}
} catch(e){
response.writeHeader(404, {"Content-Type": "text/html;charset=utf-8"});
response.write('Página não encontrada');
}
response.end();
}).listen(3000, function(){
console.log("Servidor rodando em localhost:3000");
});
```
Print no Navegador:
 | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# NodeJS - Aula 05 - Exercício
autor: Wellerson Roberto
# 1) Instale algum gerenciador de versão do Node.js e instale a versão mais atual como padrão.
Antes do gerenciados de versão:
```
node -v
v5.4.1
```
Versão mais nova no momento que faço esse exercício: 5.6.0
Usei o versionador **nvm-windows**.
Instalando a última versão:
```
nvm install latest
```
Definindo o Node.js em uso:
```
C:\Users\Wellerson>nvm use 5.6.0
Now using node v5.6.0 (64-bit)
C:\Users\Wellerson>node -v
v5.6.0
```
# 2) Inicie um projeto novo pra esse aula, com o **npm** e instale, salvando no **package.json** 1 dependência local, 1 dependência local de desenvolvimento e 1 dependência local opcional:
Iniciando o package.json:
```
npm init
```
Instalando dependência local:
```
npm i consign --save
```
Instalando dependência local de desenvolvimento:
```
npm i mocha --save-dev
```
Instalando dependência opcional:
```
npm i colors --save-optional
```
Package.json ao final:
```
{
"name": "exercicio",
"version": "1.0.0",
"description": "Fazendo exercicio do curso Be Mean",
"main": "index.js",
"scripts": {
"test": "]"
},
"author": "",
"license": "ISC",
"dependencies": {
"consign": "^0.1.2"
},
"devDependencies": {
"mocha": "^2.4.5"
},
"optionalDependencies": {
"colors": "^1.1.2"
}
}
```
# 3) Crie e execute um script, via **npm**, que mostre uma mensagem no console com a global que possui caminho para o diretório atual:
Script:
```
console.log(__dirname);
```
Package.json:
```
...
"scripts": {
"roda": "node global.js"
}
...
```
No console:
```
npm run roda
> exercicio@1.0.0 roda D:\Developer\Curso Mean\workshop-be-mean\nodejs\exercicio rapido
> node global.js
D:\Developer\Curso Mean\workshop-be-mean\nodejs\exercicio rapido
```
# 4) Cite 5 globais do Node.js e pelo menos um exemplo de cada:
**console**
Módulo que provê um console pra depurar.
```
console.log('Testando')
```
**__filename**
Mostra o caminho e o nome do arquivo do script que está sendo executado.
```
console.log(__filename)
```
**require**
Usado para requirir outros módulos
```
var mongoose = require('mongoose');
```
**Buffer**
Usado para lidar com dados binários.
```
var buff = new Buffer('Treinando!');
console.log(buff.toString());
```
**global**
O objeto que representa o namespace global do Node.js.
```
global.curso = 'Be Mean';
console.log(global.curso);
```
# 5) Explique como funciona e dê um exemplo de 'process':
O objeto global **process** é basicamente um **wrapper** do processo atual, sendo uma instância do **EventEmitter**.
Uma das propriedades desse objeto é o **argv**, que trás uma array com todos os argumentos da linha de comando usado para executar o script.
```
console.log(process.argv);
[ 'D:\\NodeJS\\node.exe', 'D:\\Developer\\Curso Mean\\workshop-be-mean\\nodejs\\exercicio rapido\\global' ]
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 05 - Exercício
**user:** [DouglasHennrich](https://github.com/DouglasHennrich)
**autor:** Douglas Hennrich
## Instale algum gerenciador de versão do Node.js e instale a versão mais atual como padrão, enquanto escrevo é a versão 5.4.0
Escolhi baixar o [NVM](https://github.com/creationix/nvm).
`node -v v5.4.1`
## Inicie um projeto novo para essa aula, com o `npm` e instale, salvando no `package.json`:
```js
npm init
This utility will walk you through creating a package.json file.
It only covers the most common items, and tries to guess sensible defaults.
See `npm help json` for definitive documentation on these fields
and exactly what they do.
Use `npm install <pkg> --save` afterwards to install a package and
save it as a dependency in the package.json file.
Press ^C at any time to quit.
name: (pokemon-api)
version: (1.0.0) 0.0.1
description: API para os pokemons
entry point: (index.js)
test command:
git repository:
keywords: api, pokemons, teta
author: Douglas Hennrich
license: (ISC)
About to write to /Users/Odin/Documents/Curso/NodeJS/Exercícios/pokemon-api/package.json:
{
"name": "pokemon-api",
"version": "0.0.1",
"description": "API para os pokemons",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"keywords": [
"api",
"pokemons",
"teta"
],
"author": "Douglas Hennrich",
"license": "ISC"
}
```
* 1 dependência local:
`npm install --save pm2`
* 1 dependência local de desenvolvimento:
`npm install --save--dev jasmine`
* 1 dependência local opcional:
`npm install --save-optional colors`
**package.json atualizado**
```js
{
"name": "pokemon-api",
"version": "0.0.1",
"description": "API para os pokemons",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"keywords": [
"api",
"pokemons",
"teta"
],
"author": "Douglas Hennrich",
"license": "ISC",
"dependencies": {
"pm2": "^1.0.0"
},
"optionalDependencies": {
"colors": "^1.1.2"
}
}
```
## Crie e execute um script, via `npm`, que mostre uma mensagem no console com a global, que possui caminho para o diretório atual.
**whereIm.js**
```js
console.log('Where Im ? ', __dirname);
```
**package.json**
```js
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
, "where": "node whereIm.js"
}
```
**npm run**
```js
npm run where
> pokemon-api@0.0.1 where /Users/Odin/Documents/Curso/NodeJS/Exercícios/pokemon-api
> node whereIm.js
Where Im ? /Users/Odin/Documents/Curso/NodeJS/Exercícios/pokemon-api
```
## Cite 5 globais do Node.js e pelo menos 1 exemplo de cada.
1. `__dirname` retorna o nome do diretório o qual o script está sendo rodado.
```js
console.log(__dirname); // /Users/Odin/Documents/Curso/NodeJS/Exercícios/pokemon-api
```
2. `setTimeout` executa uma função após determinado tempo em milisegundos.
```js
setTimeout(function(){
console.log('Mostra esse log após 1 segundo');
}, 1000);
```
3. `setInterval` executa a mesma função, a cada milisegundo pré-definido, até ser parado.
```js
setInterval(function(){
console.log('A cada 1 segundo, esse log vai aparecer!');
}, 1000);
```
4. `require` usado para requirir um módulo ou script.
```js
"use strict";
var meuScript = require('./meu_script');
```
5. `clearInterval` para a execução de um intervalo.
```js
var intervalo = setInterval(function(){
console.log('Só vai ser executado uma vez, depois será eliminado.');
clearInterval(intervalo);
}, 1000);
```
## Explique como funciona e de um exemplo de `process`.
Process é uma instancia do [EventEmitter](https://nodejs.org/api/events.html#events_class_events_eventemitter) e é uma variável Global do **NodeJS**. Como ele provem de um módulo de **eventos**, ele funciona "ouvindo" eventos e disparando callbacks sobre esses eventos capturados. Embora alguns eventos são de "mão única", não precisam de um callback.
```js
process.abort(); // Fecha o processo do NodeJS em si
```
## Criar um arquivo
```js
var fs = require('fs');
fs.writeFile('./pokemons.txt', 'Pikachu, Bulbasauro, Squirtle, Charmander', 'utf-8', function(err){
if(err) throw err;
console.log('arquivo criado');
});
```
## Ler um arquivo
```js
var fs = require('fs');
fs.readFile('./pokemons.txt', 'utf-8', function(err, data){
if(err) throw err;
console.log('Pokemons: ', data); // Pokemons: Pikachu, Bulbasauro, Squirtle, Charmander
});
```
## Editar conteúdo desse arquivo
```js
var fs = require('fs');
fs.readFile('./pokemons.txt', 'utf-8', function(err, data){
if(err) throw err;
console.log('Pokemons: ', data); // Pokemons: Pikachu, Bulbasauro, Squirtle, Charmander
fs.writeFile('./pokemons.txt', data + ', Charizard, Blastoise, Suissa', 'utf-8', function(err){
if(err) throw err;
console.log('Editado :D');
});
});
```
## Deletar arquivo
```js
var fs = require('fs');
fs.unlink('./pokemons.txt', function(err){
if(err) throw err;
console.log('arquivo deletado!');
});
```
## Renomear o arquivo
```js
var fs = require('fs');
fs.rename('whereIm.js', 'editado.js', function(err){
if(err) throw err;
console.log('arquivo renomeado');
});
```
## Desafio
**app.js**
```js
'use strict';
/*
@ Requires
*/
const http = require('http')
, fs = require('fs')
, path = require('path')
, porta = process.env.PORT || 3000
;
/*
@ Paths
*/
const html_path = __dirname + '/public';
/*
@ Server
*/
const server = http.createServer((req, res)=>{
let file = req.url
, contentType = 'text/html'
;
if(file == '/' ) {
file = '/hello.html';
}
file = html_path + file;
let extname = path.extname(file);
//Verifica os tipos de arquivo
switch ( extname.toLowerCase() ) {
case '.js':
contentType = 'text/javascript';
break;
case '.css':
contentType = 'text/css';
break;
case '.jpg':
case '.jpeg':
contentType = 'image/jpeg';
break;
}
try {
fs.accessSync(file, fs.F_OK);
fs.readFile(file, (err, data) =>{
if(err){
res.writeHead(500);
res.end();
}else{
if(extname == '.css'){
res.setHeader("Content-Type", contentType);
res.end(data);
}else{
res.writeHead(200, { contentType: contentType });
res.end(data, 'utf-8');
}
}
});
} catch (e) {
fs.readFile(html_path + '/not-found.html', (err, data) =>{
if(err){
res.writeHead(500);
res.end();
}else{
res.writeHead(200, { contentType: 'text/html' });
res.end(data);
}
});
}
})
.listen(porta, ()=>{
console.log('Static Server on localhost:' + porta);
});
```
**Screen Shots**
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 05 - Exercício
**user:** https://github.com/paulosilva92
**autor:** Paulo Roberto da Silva
**date:** Sun Mar 06 2016 00:53:19 GMT-0300 (BRT)
## Instale algum gerenciador de versão do Node.js e instale a versão mais atua como padrão.
##### Instalação do NVM
```
➜ bemean curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.31.0/install.sh | bash
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
100 7766 100 7766 0 0 5608 0 0:00:01 0:00:01 --:--:-- 5607
=> Downloading nvm from git to '/home/paulo/.nvm'
=> Cloning into '/home/paulo/.nvm'...
remote: Counting objects: 4402, done.
remote: Compressing objects: 100% (3/3), done.
remote: Total 4402 (delta 0), reused 0 (delta 0), pack-reused 4399
Receiving objects: 100% (4402/4402), 1.10 MiB | 67.00 KiB/s, done.
Resolving deltas: 100% (2582/2582), done.
Checking connectivity... done.
* (HEAD detached at v0.31.0)
master
=> Appending source string to /home/paulo/.zshrc
=> You currently have modules installed globally with `npm`. These will no
=> longer be linked to the active version of Node when you install a new node
=> with `nvm`; and they may (depending on how you construct your `$PATH`)
=> override the binaries of modules installed with `nvm`:
/usr/lib
├── lodash@4.6.1
├── nativescript@1.6.1
├── nodemon@1.9.1
=> If you wish to uninstall them at a later point (or re-install them under your
=> `nvm` Nodes), you can remove them from the system Node as follows:
$ nvm use system
$ npm uninstall -g a_module
=> Close and reopen your terminal to start using nvm
```
##### Instalação da versão mais atual do Node.js
```
➜ bemean nvm install node
Downloading https://nodejs.org/dist/v5.7.1/node-v5.7.1-linux-x64.tar.xz...
######################################################################## 100,0%
Now using node v5.7.1 (npm v3.6.0)
Creating default alias: default -> node (-> v5.7.1)
➜ bemean node -v
v5.7.1
```
## Inicie um projeto novo para essa aula, com o npm e instale, salvando no package.json
```
➜ exercicios git:(master) ✗ mkdir projeto-exercicio
➜ exercicios git:(master) ✗ cd projeto-exercicio
➜ projeto-exercicio git:(master) ✗ npm init
This utility will walk you through creating a package.json file.
It only covers the most common items, and tries to guess sensible defaults.
See `npm help json` for definitive documentation on these fields
and exactly what they do.
Use `npm install <pkg> --save` afterwards to install a package and
save it as a dependency in the package.json file.
Press ^C at any time to quit.
name: (projeto-exercicio)
version: (1.0.0)
description: "projeto de exercicio para o modulo de nodejs do bemean"
entry point: (index.js)
test command:
git repository:
keywords:
author: Paulo Roberto da Silva
license: (ISC)
About to write to /home/paulo/Documentos/bemean/be-mean-exercises/nodejs/exercicios/projeto-exercicio/package.json:
{
"name": "projeto-exercicio",
"version": "1.0.0",
"description": "\"projeto de exercicio para o modulo de nodejs do bemean\"",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"author": "Paulo Roberto da Silva",
"license": "ISC"
}
Is this ok? (yes)
```
### 1 dependência local
```
➜ projeto-exercicio git:(master) ✗ npm i express -S
projeto-exercicio@1.0.0 /home/paulo/Documentos/bemean/be-mean-exercises/nodejs/exercicios/projeto-exercicio
└─┬ express@4.13.4
├─┬ accepts@1.2.13
│ ├─┬ mime-types@2.1.10
│ │ └── mime-db@1.22.0
│ └── negotiator@0.5.3
├── array-flatten@1.1.1
├── content-disposition@0.5.1
├── content-type@1.0.1
├── cookie@0.1.5
├── cookie-signature@1.0.6
├─┬ debug@2.2.0
│ └── ms@0.7.1
├── depd@1.1.0
├── escape-html@1.0.3
├── etag@1.7.0
├─┬ finalhandler@0.4.1
│ └── unpipe@1.0.0
├── fresh@0.3.0
├── merge-descriptors@1.0.1
├── methods@1.1.2
├─┬ on-finished@2.3.0
│ └── ee-first@1.1.1
├── parseurl@1.3.1
├── path-to-regexp@0.1.7
├─┬ proxy-addr@1.0.10
│ ├── forwarded@0.1.0
│ └── ipaddr.js@1.0.5
├── qs@4.0.0
├── range-parser@1.0.3
├─┬ send@0.13.1
│ ├── destroy@1.0.4
│ ├─┬ http-errors@1.3.1
│ │ └── inherits@2.0.1
│ ├── mime@1.3.4
│ └── statuses@1.2.1
├── serve-static@1.10.2
├─┬ type-is@1.6.12
│ └── media-typer@0.3.0
├── utils-merge@1.0.0
└── vary@1.0.1
npm WARN projeto-exercicio@1.0.0 No repository field.
```
### 1 dependência local de desenvolvimento
```
➜ projeto-exercicio git:(master) ✗ npm i gulp -D
projeto-exercicio@1.0.0 /home/paulo/Documentos/bemean/be-mean-exercises/nodejs/exercicios/projeto-exercicio
└─┬ gulp@3.9.1
├── archy@1.0.0
├─┬ chalk@1.1.1
│ ├─┬ ansi-styles@2.2.0
│ │ └── color-convert@1.0.0
│ ├── escape-string-regexp@1.0.5
│ ├─┬ has-ansi@2.0.0
│ │ └── ansi-regex@2.0.0
│ ├── strip-ansi@3.0.1
│ └── supports-color@2.0.0
├── deprecated@0.0.1
├─┬ gulp-util@3.0.7
│ ├── array-differ@1.0.0
│ ├── array-uniq@1.0.2
│ ├── beeper@1.1.0
│ ├─┬ dateformat@1.0.12
│ │ ├── get-stdin@4.0.1
│ │ └─┬ meow@3.7.0
│ │ ├─┬ camelcase-keys@2.0.0
│ │ │ └── camelcase@2.1.0
│ │ ├── decamelize@1.2.0
│ │ ├─┬ loud-rejection@1.3.0
│ │ │ ├── array-find-index@1.0.1
│ │ │ └── signal-exit@2.1.2
│ │ ├── map-obj@1.0.1
│ │ ├─┬ normalize-package-data@2.3.5
│ │ │ ├── hosted-git-info@2.1.4
│ │ │ ├─┬ is-builtin-module@1.0.0
│ │ │ │ └── builtin-modules@1.1.1
│ │ │ └─┬ validate-npm-package-license@3.0.1
│ │ │ ├─┬ spdx-correct@1.0.2
│ │ │ │ └── spdx-license-ids@1.2.0
│ │ │ └─┬ spdx-expression-parse@1.0.2
│ │ │ └── spdx-exceptions@1.0.4
│ │ ├── object-assign@4.0.1
│ │ ├─┬ read-pkg-up@1.0.1
│ │ │ ├─┬ find-up@1.1.2
│ │ │ │ ├── path-exists@2.1.0
│ │ │ │ └─┬ pinkie-promise@2.0.0
│ │ │ │ └── pinkie@2.0.4
│ │ │ └─┬ read-pkg@1.1.0
│ │ │ ├─┬ load-json-file@1.1.0
│ │ │ │ ├── graceful-fs@4.1.3
│ │ │ │ ├─┬ parse-json@2.2.0
│ │ │ │ │ └─┬ error-ex@1.3.0
│ │ │ │ │ └── is-arrayish@0.2.1
│ │ │ │ ├── pify@2.3.0
│ │ │ │ └── strip-bom@2.0.0
│ │ │ └── path-type@1.1.0
│ │ ├─┬ redent@1.0.0
│ │ │ ├─┬ indent-string@2.1.0
│ │ │ │ └─┬ repeating@2.0.0
│ │ │ │ └─┬ is-finite@1.0.1
│ │ │ │ └── number-is-nan@1.0.0
│ │ │ └── strip-indent@1.0.1
│ │ └── trim-newlines@1.0.0
│ ├─┬ fancy-log@1.2.0
│ │ └── time-stamp@1.0.0
│ ├─┬ gulplog@1.0.0
│ │ └── glogg@1.0.0
│ ├─┬ has-gulplog@0.1.0
│ │ └── sparkles@1.0.0
│ ├── lodash._reescape@3.0.0
│ ├── lodash._reevaluate@3.0.0
│ ├── lodash._reinterpolate@3.0.0
│ ├─┬ lodash.template@3.6.2
│ │ ├── lodash._basecopy@3.0.1
│ │ ├── lodash._basetostring@3.0.1
│ │ ├── lodash._basevalues@3.0.0
│ │ ├── lodash._isiterateecall@3.0.9
│ │ ├─┬ lodash.escape@3.2.0
│ │ │ └── lodash._root@3.0.1
│ │ ├─┬ lodash.keys@3.1.2
│ │ │ ├── lodash._getnative@3.9.1
│ │ │ ├── lodash.isarguments@3.0.8
│ │ │ └── lodash.isarray@3.0.4
│ │ ├── lodash.restparam@3.6.1
│ │ └── lodash.templatesettings@3.1.1
│ ├─┬ multipipe@0.1.2
│ │ └─┬ duplexer2@0.0.2
│ │ └── readable-stream@1.1.13
│ ├── object-assign@3.0.0
│ ├── replace-ext@0.0.1
│ ├─┬ through2@2.0.1
│ │ ├─┬ readable-stream@2.0.5
│ │ │ ├── core-util-is@1.0.2
│ │ │ ├── isarray@0.0.1
│ │ │ ├── process-nextick-args@1.0.6
│ │ │ ├── string_decoder@0.10.31
│ │ │ └── util-deprecate@1.0.2
│ │ └── xtend@4.0.1
│ └─┬ vinyl@0.5.3
│ ├── clone@1.0.2
│ └── clone-stats@0.0.1
├── interpret@1.0.0
├─┬ liftoff@2.2.0
│ ├── extend@2.0.1
│ ├─┬ findup-sync@0.3.0
│ │ └─┬ glob@5.0.15
│ │ ├── inflight@1.0.4
│ │ ├── minimatch@3.0.0
│ │ └── path-is-absolute@1.0.0
│ ├── flagged-respawn@0.3.1
│ ├── rechoir@0.6.2
│ └── resolve@1.1.7
├── minimist@1.2.0
├─┬ orchestrator@0.3.7
│ ├─┬ end-of-stream@0.1.5
│ │ └─┬ once@1.3.3
│ │ └── wrappy@1.0.1
│ ├── sequencify@0.0.7
│ └── stream-consume@0.1.0
├── pretty-hrtime@1.0.2
├── semver@4.3.6
├─┬ tildify@1.1.2
│ └── os-homedir@1.0.1
├─┬ v8flags@2.0.11
│ └── user-home@1.1.1
└─┬ vinyl-fs@0.3.14
├── defaults@1.0.3
├─┬ glob-stream@3.1.18
│ ├── glob@4.5.3
│ ├─┬ glob2base@0.0.12
│ │ └── find-index@0.1.1
│ ├─┬ minimatch@2.0.10
│ │ └─┬ brace-expansion@1.1.3
│ │ ├── balanced-match@0.3.0
│ │ └── concat-map@0.0.1
│ ├── ordered-read-streams@0.1.0
│ ├─┬ through2@0.6.5
│ │ └── readable-stream@1.0.33
│ └── unique-stream@1.0.0
├─┬ glob-watcher@0.0.6
│ └─┬ gaze@0.5.2
│ └─┬ globule@0.1.0
│ ├─┬ glob@3.1.21
│ │ ├── graceful-fs@1.2.3
│ │ └── inherits@1.0.2
│ ├── lodash@1.0.2
│ └─┬ minimatch@0.2.14
│ ├── lru-cache@2.7.3
│ └── sigmund@1.0.1
├── graceful-fs@3.0.8
├─┬ mkdirp@0.5.1
│ └── minimist@0.0.8
├─┬ strip-bom@1.0.0
│ ├── first-chunk-stream@1.0.0
│ └── is-utf8@0.2.1
├─┬ through2@0.6.5
│ └── readable-stream@1.0.33
└─┬ vinyl@0.4.6
└── clone@0.2.0
```
### 1 dependência local opcional
```
➜ projeto-exercicio git:(master) ✗ npm i ejs -S
projeto-exercicio@1.0.0 /home/paulo/Documentos/bemean/be-mean-exercises/nodejs/exercicios/projeto-exercicio
└── ejs@2.4.1
npm WARN projeto-exercicio@1.0.0 No repository field.
```
## Crie um *script*, via npm, que mostre uma mensagem no console com a global que possui o caminho para o diretório atual
##### Código do arquivo *path.js*
```
console.log(process.cwd());
```
##### Criação do script no package.json
```js
"scripts": {
"caminho": "node path.js",
"test": "echo \"Error: no test specified\" && exit 1"
},
```
##### Execução do script
```
➜ projeto-exercicio git:(master) ✗ npm run-script caminho
> projeto-exercicio@1.0.0 caminho /home/paulo/Documentos/bemean/be-mean-exercises/nodejs/exercicios/projeto-exercicio
> node path.js
/home/paulo/Documentos/bemean/be-mean-exercises/nodejs/exercicios/projeto-exercicio
```
## Cite 5 globais do Node e pelo menos 1 exemplo de cada
##### __filename
Contém o caminho do arquivo que está sendo executado.
```js
console.log(__filename);
// /home/paulo/Documentos/bemean/be-mean-exercises/nodejs/exercicios/teste.js
```
##### require();
Utilizado para importar módulos. Tem-se que passar para essa função o caminho onde o módulo se encontra.
```js
const modulo = require('./modulos/modulo.js');
```
##### console
Utilizado para mostrar saidas de texto ou conteudos de variaveis,funções objetos e etc.
```js
> console.log('Ola %s', 'Mundo');
Ola Mundo
```
##### setInterval
Roda uma função repetidamente durante a cada periode de tempo determinado pelo usuário. Essa função recebe dois parâmetros, o primeiro parâmetro é a função que será repetida e o segundo é o tempo entre cada repetição em milisegundos.
```js
setInterval(function(){
console.log('intervalo');
},1000)
```
##### setTimeout
Roda uma função após determinado tempo. Essa função recebe dois parâmetros, o primeiro é a função a ser repetida e o segundo é o tempo em milisegundos.
```js
setTimeout(function(){
console.log('intervalo');
},2000);
```
## Explique como funciona e de um exemplo de *process*
*process* é uma instância do *EvenEmitter*, ou seja, um objeto global que contém, além de métodos, eventos. É utilizado para manipuar e ver algumas informações sobre o ambiente de execução da aplicação.
```js
setTimeout(function(){
console.log('intervalo');
},2000);
console.log(process.uptime()); //mostra a quantidade de tempo que a aplicação está em execução
//Resposta :
// 0.101
// intervalo
```
## Criar um arquivo
```js
const fs = require('fs');
fs.writeFileSync('teste.txt', 'Esse é um texto para o arquivo de teste', 'utf-8');
```
## Ler um arquivo
```js
var teste = fs.readFileSync('./teste.txt', 'utf-8');
console.log(teste);
//Esse é um texto para o arquivo de teste
```
## Editar um arquivo
```js
fs.writeFileSync('teste.txt', 'Esse é um texto modificado para fazer update no arquivo de teste', 'utf-8');
var teste = fs.readFileSync('./teste.txt', 'utf-8');
console.log(teste);
//Esse é um texto modificado para fazer update no arquivo de teste
```
## Deletar um arquivo
```js
fs.unlinkSync('./teste.txt');
```
## Renomear um arquivo
```js
fs.renameSync('./teste.txt', './novoteste.txt');
var teste = fs.readFileSync('./novoteste.txt', 'utf-8');
console.log(teste);
```
## Desafio: Criar um servidor web de arquivos estáticos: css, html, js e etc;
Colocar este código num arquivo com nome de `app.js` e rodar com o node
```js
const http = require('http');
const fs = require('fs');
http.createServer((req, res)=> {
fs.readFile(__dirname + req.url, function (err,data) {
if (err) {
res.writeHead(404);
console.log(err);
res.end("Página não encontrada");
return;
}
res.writeHead(200);
res.end(data);
});
}).listen(3000, ()=>{
console.log('Server rodando na porta 3000');
});
```
Colocando no navegador `http://localhost:3000/app.js` veremos então o código do nosso arquivo que cria o servidor | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 05 - Exercício
**user:** [xereda](https://github.com/xereda)
**autor:** Jackson Ricardo Schroeder
## Instale algum gerenciador de versão do Node.js e instale a versão mais atual como padrão, enquanto escrevo é a versão 5.4.0
```
nvm install 6.2.1
Downloading https://nodejs.org/dist/v6.2.1/node-v6.2.1-darwin-x64.tar.gz...
######################################################################## 100,0%
Now using node v6.2.1 (npm v3.9.3)
node -v
v6.2.1
npm -v
3.9.3
```
## Inicie um projeto novo para essa aula, com o `npm` e instale, salvando no `package.json`:
```
npm init
This utility will walk you through creating a package.json file.
It only covers the most common items, and tries to guess sensible defaults.
See `npm help json` for definitive documentation on these fields
and exactly what they do.
Use `npm install <pkg> --save` afterwards to install a package and
save it as a dependency in the package.json file.
Press ^C at any time to quit.
name: (npm) exercicio05-nodejs
version: (1.0.0) 0.0.1
description: Exercício da aula 05 de NodeJS
entry point: (index.js)
test command:
git repository:
keywords: nodejs node aulas aula05 javascript bemean
author: Jackson Ricardo Schroeder
license: (ISC)
About to write to /Users/xereda/Sites/bemean/nodejs/aula05/npm/package.json:
{
"name": "exercicio05-nodejs",
"version": "0.0.1",
"description": "Exercício da aula 05 de NodeJS",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"keywords": [
"nodejs",
"node",
"aulas",
"aula05",
"javascript",
"bemean"
],
"author": "Jackson Ricardo Schroeder",
"license": "ISC"
}
Is this ok? (yes) yes
```
- 1 dependência local
```
npm install --save mongoose
```
- 1 dependência local de desenvolvimento
```
npm install --save-dev jasmine
```
- 1 dependência local opcional
```
npm install --save-optional color
```
- Arquivo package.json atualizado
```js
cat package.json
{
"name": "exercicio05-nodejs",
"version": "0.0.1",
"description": "Exercício da aula 05 de NodeJS",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"keywords": [
"nodejs",
"node",
"aulas",
"aula05",
"javascript",
"bemean"
],
"author": "Jackson Ricardo Schroeder",
"license": "ISC",
"dependencies": {
"mongoose": "^4.4.20"
},
"devDependencies": {
"jasmine": "^2.4.1"
},
"optionalDependencies": {
"color": "^0.11.1"
}
}
```
## Crie e execute um script, via `npm`, que mostre uma mensagem no console com a global, que possui caminho para o diretório atual.
```js
// script.js
console.log("Diretório atual: " + __dirname);
// package.json
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1",
"aula": "node script.js"
}
> exercicio05-nodejs@0.0.1 aula /Users/xereda/Sites/bemean/nodejs/aula05/npm
> node script.js
Diretório atual: /Users/xereda/Sites/bemean/nodejs/aula05/npm
```
## Cite 5 globais do Node.js e pelo menos 1 exemplo de cada.
```js
//interacao com o console do nodejs (console)
console.log(__dirname); // __dirname outra global que apresenta o caminho do diretorio atual
console.log(__filename); // __filename outra global que apresenta o caminho e o nome do módulo atual
require("http"); // require é uma global que requere e incorpora um módulo
// setInterval e setTimeout são exemplos de funcoes globais
// no exemplo abaixo, estamos executando uma rotina a cada dois segundos
const rotina2sec = setInterval(() => {
console.log("Vai executar a cada 2 segundos: " + Date.now());
}, 2000);
// abaixo a funcao global setTimeout() vai encerrar a execucao
// da rotina acima apos 8 segundos, para isso usamos clearInterval() como parametro
setTimeout(() => {
console.log("vai encerrar a rotina...");
clearInterval(rotina2sec);
}, 9000);
```
## Explique como funciona e de um exemplo de `process`.
É um objeto global que pode ser acessado de qualquer lugar e é uma instância de EventEmitter. Alguns eventos suportados pelo process EventEmitter:
- **exit**
- **beforeExit**
- **uncaughtException**
- **Signal Events**
```js
//process.js
"use strict";
const http = require("http");
process.nextTick(() => console.log("Eu sou uma async"));
console.log(process.execPath);
console.log(process.cwd());
console.log(process.pid);
const server = http.createServer((req, res) => {
res.write("vai sair no browser");
res.end();
});
server.listen(3000, () => console.log("Servidor rodando na porta 3000"));
process.on("SIGINT", () => {
console.log("finalizando o servidor");
process.exit(0);
});
// executando o process.js
node process.js
/usr/local/bin/node
/Users/xereda/Sites/bemean/nodejs/aula05/npm
1819
Eu sou uma async
Servidor rodando na porta 3000
^Cfinalizando o servidor
```
## File System
### Criar um arquivo.
```js
// criar.js
var fs = require('fs')
var write = fs.writeFileSync("ola.txt","Olá mundo!");
$> node criar.js
$> ls
criar.js ola.txt
```
### Ler um arquivo.
```js
// ler.js
var fs = require('fs');
fs.readFile('ola.txt', 'utf8', (err, data) => {
if (err) throw err;
console.log(data);
});
$> node ler.js
Olá mundo!
```
### Editar conteúdo desse arquivo.
```js
// file: editar.js
"use strict";
var fs = require('fs');
fs.readFile('ola.txt', 'utf-8', (err, data) => {
if (err) throw err;
var update = data + "\nNovo conteúdo no arquivo!";
fs.writeFile('ola.txt', update, 'utf-8', err => {
if (err) throw err;
console.log(update);
});
});
$> node editar.js
Olá mundo!
Novo conteúdo no arquivo!
$> more ola.txt
Olá mundo!
Novo conteúdo no arquivo!
```
### Renomear o arquivo.
```js
// renomear.js
var fs = require('fs');
fs.rename('ola.txt', 'ola_renomeado.txt', err => {
if (err) throw err;
})
$> ls
criar.js editar.js ler.js ola.txt renomear.js
$> node renomear.js
$> ls
criar.js editar.js ler.js ola_renomeado.txt renomear.js
```
### Deletar arquivo.
```js
// file: excluir.js
var fs = require('fs');
fs.unlink('ola_renomeado.txt', err => {
if (err) throw err;
});
$> ls
criar.js editar.js excluir.js ler.js ola_renomeado.txt renomear.js
$> node excluir.js
$> ls
criar.js editar.js excluir.js ler.js renomear.js
```
## Desafio: Criar um servidor web de arquivos estáticos.
```js
"use strict";
const http = require("http");
const url = require("url");
const path = require("path");
const fs = require("fs");
const port = process.argv[2] || 8888;
http.createServer((request, response) => {
var uri = url.parse(request.url).pathname
, filename = path.join(process.cwd(), uri);
fs.exists(filename, (exists) => {
if(!exists) {
response.writeHead(404, {"Content-Type": "text/html; charset=utf-8"});
response.write("404 = Arquivo não encontrado\n");
response.end();
return;
}
if (fs.statSync(filename).isDirectory()) filename += '/index.html';
fs.readFile(filename, "binary", (err, file) => {
if(err) {
response.writeHead(500, {"Content-Type": "text/html; charset=utf-8"});
response.write(err + "\n");
response.end();
return;
}
response.writeHead(200);
response.write(file, "binary");
response.end();
});
});
}).listen(parseInt(port, 10));
console.log("Static file server rodando em \n => http://localhost:" + port + "/\nCTRL + C to parar execução do servidor");
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 07 - Exercício
**user:** [FranciscoValerio](https://github.com/FranciscoValerio)
**autor:** Francisco Henrique Ruiz Valério
#1 - Crie um função que entenda de EventEmitter, nela crie um method, um chamado init, ele devera ser chamado toda vez que a sua função foi iniciada. Use o código 04 Como base.(use ele no prototype).#
**arquivo (eventEmitter.js)**
```JS
'use strict';
const EventEmitter = require( 'events' ).EventEmitter;
const util = require( 'util' );
function Aviso ( data ) {
this.data = data
this.on('aviso:init', sendInit);
this.on('error', sendError);
EventEmitter.call( this );
}
Aviso.prototype.init = function () {
if ( this.data.msg ){
this.emit('aviso:init', this.data);
} else {
this.emit('error', new TypeError('Message empty!' ) );
}
};
util.inherits( Aviso, EventEmitter );
function sendInit( data ) {
console.log(data.msg);
}
function sendError( err ) {
throw err;
}
module.exports = Aviso;
```
**arquivo (emitter.js)**
```JS
'use strict';
const Aviso = require( './eventEmitter' );
const aviso = new Aviso({ msg: 'class-07'});
aviso.init();
```
#2 - Faça, um modulo simples para ler diretórios usando modulo FS(fs.readdir), usando o exemplo do código 03, esse modulo deve retornar uma Promise.#
**arquivo (read-dir.js)**
```JS
'use strict';
const fs = require( 'fs' );
function readDirectory(path){
return new Promise(function(resolve, reject){
fs.readdir( path, (err, data) => {
err ? reject( err ) : resolve( data );
});
});
}
module.exports = readDirectory;
```
**arquivo (promisse-all)**
```JS
'use strict';
function promiseAll(arr){
return Promise.all(arr).then( function success(res){
return res;
})
.catch(function error(err){
throw err;
});
}
module.exports = promiseAll;
```
**arquivo (app.js)**
```JS
'use strict';
const promiseAll = require( './promisse-all' );
const readDirectory = require( './read-dir' );
promiseAll([
readDirectory( './' ),
readDirectory( '../' ),
])
.then( res => console.log('resposta:', res))
.catch(err => console.error('error:', err));
```
#3 - Os schemas do mongoose podem usar promises, em seus alguns methods, de “crud”, list 3 methods que usam promise , se chamada da função exec(), no final e 3 que usam exec(), mostre ao menos um exemplo de cada.#
**methods**
> 1 - find().
> 2 - delete().
> 3 - update().
**Exemplo: 1 - find()**
```JS
'use strict';
const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/francisco');
const Pokemon = require( './pokemon');
let promise = Pokemon.find({}).exec();
promise.then(success, error);
function success(data){
console.log('retorno: ', data );
}
function error(err){
console.error('erro: ', err );
}
```
**Exemplo: 2 - delete()**
```JS
'use strict';
const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/francisco');
const Pokemon = require( './pokemon');
let promise = Pokemon.remove({
_id: '56aa9ca4eabaf61c0fffc3e9'
}).exec();
promise.then(success, error);
function success(data){
console.log('retorno: ', data );
}
function error(err){
console.error('erro: ', err );
}
```
**Exemplo: 3 - update()**
```JS
'use strict';
const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/francisco');
const Pokemon = require( './pokemon');
const pokemon = {
name: "Francisco",
type: "Fire",
attack: 88,
defence: 99,
height: 1.85,
description: "man"
};
let promise = Pokemon.update({
_id: '56aa9ca4eabaf61c0fffc3e9'},
pokemon
).exec();
promise.then(success, error);
function success(data){
console.log('retorno: ', data );
}
function error(err){
console.error('erro: ', err );
}
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 07 - Exercício
**user:** [filipe1309](https://github.com/filipe1309)
**autor:** Filipe Leuch Bonfim
### 1 - Crie um função que entenda de EventEmitter, nela crie um method, um chamado init, ele devera ser chamado toda vez que a sua função foi iniciada. Use o código 04 Como base.(use ele no prototype).
#### ex1_init_event.js
```js
'use strict';
const EventEmitter = require('events').EventEmitter;
const util = require('util');
function BazingaEmitter (data) {
this.data = data;
this.on('init', init);
EventEmitter.call(this);
}
BazingaEmitter.prototype.init = function () {
this.emit('init', this.data);
};
util.inherits(BazingaEmitter, EventEmitter);
function init (data) {
console.log('init =>', data.text);
}
module.exports = BazingaEmitter;
```
#### ex1_init_event_main.js
```js
'use strict';
const BazingaEmitter = require( './ex1_init_event.js' );
const myBazingaEmitter = new BazingaEmitter({ text: 'Bazinga!!!'});
myBazingaEmitter.init();
```
#### Saída
```
$ node ex1_init_event_main.js
init => Bazinga!!!
```
### 2 - Faça, um modulo simples para ler diretórios usando modulo FS(fs.readdir), usando o exemplo do código 03, esse modulo deve retornar uma Promise.
#### ex2_readdir_promise.js
```js
'use strict';
const fs = require('fs');
function readDir(path) {
return new Promise(function (resolve, reject) {
fs.readdir(path, function (err, res) {
err ? reject(err) : resolve(res);
});
});
}
module.exports = readDir;
```
#### ex2_readdir_promise_main.js
```js
'use strict';
const readDir = require('./ex2_readdir_promise.js');
function myPromiseAll(arr) {
return Promise.all(arr)
.then(result => { return result; })
.catch(err => { throw err; });
}
myPromiseAll([
readDir('../class07'),
readDir('../class02')
])
.then(result => console.log(result))
.catch(err => console.log(err));
```
### 3 - Os schemas do mongoose podem usar promises, em seus alguns methods, de “crud”, list 3 methods que usam promise , se chamada da função exec(), no final e 3 que usam exec(), mostre ao menos um exemplo de cada.
#### 3 - sem `exec()`:
- `find`,
- `create`,
- `remove`
#### 3 - com `exec()`:
- `find`,
- `findOne`,
- `update`
#### ex3_mongoose_promise.js
```js
'use strict';
// Conexão com o mongo
const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/be-mean-modulo-nodejs-exercises');
// Definição do Schema
const Schema = mongoose.Schema;
const bandsSchema = new Schema({
name: String
});
// Definição do Model
const BandsModel = mongoose.model('bands', bandsSchema);
const band1 = {
name: 'Manonas assassinas'
};
// 3 métodos - sem exec()
const findPromise = BandsModel.find({name: 'Linkin Park'});
findPromise.then(success, error);
// [ { name: 'Linkin Park', _id: 56ff424dcb3f181e1d0ae7a6 } ]
const createPromise = BandsModel.create(band1)
createPromise.then(success , error);
// { _id: 56ff4d03d20057e62669be34, name: 'Manonas assassinas', __v: 0 }
const removePromise = BandsModel.remove({name : band1.name });
removePromise.then(success , error);
// result: { ok: 1, n: 1 }
// 3 métodos - com exec()
const findPromiseExec = BandsModel.find({name: 'Ramones'}).exec();
findPromiseExec.then(success, error);
//[ { name: 'Ramones', _id: 56ff422bcb3f181e1d0ae7a5 } ]
const findOnepromise = BandsModel.findOne({ name: 'Metallica' }).exec();
findOnepromise.then(success , error);
//{ name: 'Metallica', _id: 56ff3ef8cb3f181e1d0ae7a4 }
const updatePromise = BandsModel.update({ name : 'Metallica'}, {name: '+Metallica'}).exec();
updatePromise.then(success , error);
//{ ok: 1, nModified: 1, n: 1 }
function success(data) {
console.log(data);
}
function error (err) {
console.log(err);
}
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 07 - Exercício
**user:** [ednilsonamaral](https://github.com/ednilsonamaral)
**autor:** Ednilson Amaral
## 1 - Crie um função que entenda de EventEmitter, nela crie um method, um chamado init, ele devera ser chamado toda vez que a sua função foi iniciada. Use o código 04 como base (use ele no prototype).
`eventEmitter.js`
```js
'use strict';
//chamando os módulos necessários
const EventEmitter = require('events').EventEmitter;
const util = require('util');
//ouvindo
function HelloWorld(data){
this.data = data;
this.on('hello:init', showInit);
this.on('erro', showError);
EventEmitter.call(this);
}
//emitindo
HelloWorld.prototype.init = function() {
if (this.data.msg) {
this.emit('hello:init', this.data);
} else {
this.emit('erro', new TypeError('Nenhuma mensagem para mostrar'));
}
};
//utilizando o util para herança, inserção de objetos, logs, etc
util.inherits(HelloWorld, EventEmitter);
//função do showInit;
function showInit (data){
console.log(data.msg);
}
//função do showError
function showError (err){
throw err;
}
//criando a mensagem para ser mostrada
const mensagem = new HelloWorld({msg: 'Olá, mundo!'});
mensagem.init();
```
Saída no terminal:
```
$ node event.js
Olá, mundo!
```
## 2 - Faça, um modulo simples para ler diretórios usando modulo FS(fs.readdir), usando o exemplo do código 03, esse modulo deve retornar uma Promise.
`readFilesPromise.js`
```js
'use strict';
const fs = require('fs');
function readDir (path) {
return new Promise(function (res, rej) {
fs.readdir(path, function (err, data) {
err ? rej(err) : res(res);
});
});
}
readDir('./exemplos/')
.then(function (data) {
success(data);
})
.catch(function (err){
error(err);
});
function success (data) {
console.log(data);
}
function error (err) {
console.log(err);
}
```
Saída no terminal:
```
$ node readFilesPromise.js
[Function]
```
Fiz um segundo teste, alterando o caminho desejado, de `./exemplos/` para `./exemploo/`, então obtive o segundo erro, assumindo o estado de *reject*:
```
$ node readFilesPromise.js
{ [Error: ENOENT: no such file or directory, scandir './exemploo/']
errno: -2,
code: 'ENOENT',
syscall: 'scandir',
path: './exemploo/' }
```
## 3 - Os schemas do mongoose podem usar promises, em seus alguns methods, de “crud”, list 3 methods que usam promise , se chamada da função exec(), no final e 3 que usam exec(), mostre ao menos um exemplo de cada.
Os *methods* escolhidos foram:
* `create`;
* `find`;
* `update`;
* `delete`.
`createPromise.js`
```js
'use strict';
const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/bancoTeste');
const Schema = mongoose.Schema;
const _schema = {
nome: {type: String, match: /^./i },
idade: {type: Number, min: 1},
sexo: {type: String, enum: ['M', 'F']},
cidade: {type: String, maxlength: 10},
estado: {type: String, minlength: 2}
}
const personData = {
nome: 'Ednilson Amaral',
idade: 24,
sexo: 'M',
cidade: 'Itapeva',
estado: 'SP'
}
const personSchema = new Schema(_schema);
const Person = mongoose.model('Person', personSchema);
//create
Person.create(personData).then(success, error);
function success(data) {
console.log('Inseriu: ', data);
}
function error (error) {
console.log('Erro: ', error);
}
```
Saída no Terminal:
```
$ node createPromise.js
Inseriu: { _id: 56d59b09d95812f013f70a68,
estado: 'SP',
cidade: 'Itapeva',
sexo: 'M',
idade: 24,
nome: 'Ednilson Amaral',
__v: 0 }
```
`findPromise.js`
```js
'use strict';
const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/bancoTeste');
const Schema = mongoose.Schema;
const _schema = {
nome: {type: String, match: /^./i },
idade: {type: Number, min: 1},
sexo: {type: String, enum: ['M', 'F']},
cidade: {type: String, maxlength: 10},
estado: {type: String, minlength: 2}
}
const personSchema = new Schema(_schema);
const Person = mongoose.model('Person', personSchema);
const personFind = {nome: /ednilson amaral/i};
//find
let promise = Person.find(personFind).exec();
promise.then(success, error);
function success(data) {
console.log('Encontrou: ', data);
}
function error (error) {
console.log('Erro: ', error);
}
```
Saída no terminal:
```
$ node findPromise.js
Encontrou: [ { __v: 0,
estado: 'SP',
cidade: 'Itapeva',
sexo: 'M',
idade: 24,
nome: 'Ednilson Amaral',
_id: 56d59ae24d6f8ae513f6ff1d },
{ __v: 0,
estado: 'SP',
cidade: 'Itapeva',
sexo: 'M',
idade: 24,
nome: 'Ednilson Amaral',
_id: 56d59b09d95812f013f70a68 } ]
```
`updatePromise.js`
```js
'use strict';
const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/bancoTeste');
const Schema = mongoose.Schema;
const _schema = {
nome: {type: String, match: /^./i },
idade: {type: Number, min: 1},
sexo: {type: String, enum: ['M', 'F']},
cidade: {type: String, maxlength: 10},
estado: {type: String, minlength: 2}
}
const personSchema = new Schema(_schema);
const Person = mongoose.model('Person', personSchema);
//update
const personUpdate = {nome: 'Ed'};
const personId = {"_id": "56d59ae24d6f8ae513f6ff1d"};
let promise = Person.update(personId, personUpdate).exec();
promise.then(success, error);
function success(data) {
console.log('Encontrou: ', data);
}
function error (error) {
console.log('Erro: ', error);
}
```
Saída no terminal:
```
$ node updatePromise.js
Encontrou: { ok: 1, nModified: 1, n: 1 }
```
`deletePromise.js`
```js
'use strict';
const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/bancoTeste');
const Schema = mongoose.Schema;
const _schema = {
nome: {type: String, match: /^./i },
idade: {type: Number, min: 1},
sexo: {type: String, enum: ['M', 'F']},
cidade: {type: String, maxlength: 10},
estado: {type: String, minlength: 2}
}
const personSchema = new Schema(_schema);
const Person = mongoose.model('Person', personSchema);
//remove
const personId = {"_id": "56d59b09d95812f013f70a68"};
let promise = Person.remove(personId).exec();
promise.then(success, error);
function success(data) {
console.log('Removeu: ', data);
}
function error (error) {
console.log('Erro: ', error);
}
```
Saída no terminal:
```
$ node deletePromise.js
Removeu: { result: { ok: 1, n: 1 },
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 07 - Exercício
**user**: [victorvoid](https://github.com/victorvoid)
**autor**: Victor Igor Gomes Martins
**date**: 1458942620128
# Crie um função que entenda de EventEmitter, nela crie um method, um chamado init, ele devera ser chamado toda vez que a sua função foi iniciada. Use o código 04 Como base.(use ele no prototype).
```js
'use strict';
const EventEmitter = require('events').EventEmitter;
const util = require('util');
function User (data) {
this.data = data;
this.on('user:init', olaUser);
this.on('error', sendError);
EventEmitter.call(this);
}
User.prototype.init = function () {
if(this.data.name){
this.emit('user:init',this.data);
}
else {
this.emit('error', new TypeError('User need an name'));
}
};
util.inherits(User, EventEmitter);
function olaUser(user) {
console.log('Olá', user.name);
}
function sendError(err) {
throw err;
}
const user = new User({name: 'Victor'});
user.init();
```
saida:
```
node app-1.js
Olá Victor
```
# Faça, um modulo simples para ler diretórios usando modulo FS(fs.readdir), usando o exemplo do código 03, esse modulo deve retornar uma Promise.
- fs-promise.js
```js
'use strict';
const fs = require('fs');
module.exports = (path)=>{
return new Promise((resolve, reject)=>{
fs.readdir(path, (err, files)=>{
err ? reject(err) : resolve(files);
});
});
}
```
- app.js
```js
'use strict';
const readdir = require('./fs-promise');
readdir('./').then(sucess, failed);
function sucess(data){
console.log(data);
}
function failed(err) {
console.log(err);
}
```
saida:
```
node app.js
[ 'app.js', 'carros.txt', 'fs-promise.js' ]
```
# Os schemas do mongoose podem usar promises, em seus alguns methods, de “crud”, list 3 methods que usam promise , se chamada da função exec(), no final e 3 que usam exec(), mostre ao menos um exemplo de cada.
- pokemon.js
```js
'use strict';
const mongoose = require('mongoose');
const util = require('util');
function pokemonHandler() {
let Schema = mongoose.Schema;
const ObjectId = Schema.ObjectId;
const schema = new Schema({
id : ObjectId,
name : {type : String, trin : true},
type : {type : String, trin : true},
attack : {type : Number},
defence : {type : Number},
height : {type : Number},
description : {type : String, trin : true}
});
return mongoose.model('Pokemons', schema);
}
module.exports = exports = pokemonHandler();
```
- Find
```js
'use strict';
const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/be-mean-instagram');
const Pokemon = require('./pokemon');
let poke = Pokemon.find({name: 'pikachu'}).exec();
poke.then(success, failed);
function success(data) {
if(data.length <= 0)
console.log('Nada encontrado');
else
console.log(data);
}
function failed (err) {
console.log(err);
}
```
saida:
```js
node app.js
Nada encontrado
```
- FindOne
```js
'use strict';
const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/be-mean-instagram');
const Pokemon = require('./pokemon');
let poke = Pokemon.findOne({_id: "56f484bffcbb4f03287baa27"}).exec();
poke.then(success, failed);
function success(data) {
console.log(data);
}
function failed (err) {
console.log(err);
}
```
saida:
```js
node app.js
{ __v: 0,
created_at: Thu Mar 24 2016 20:22:23 GMT-0400 (AMT),
height: 0.7,
defense: 96,
attack: 69,
type: 'terra',
description: 'Vai que vai',
name: 'Atomicmon',
_id: 56f484bffcbb4f03287baa27 }
```
- Remove
```js
'use strict';
const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/be-mean-instagram');
const Pokemon = require('./pokemon');
let poke = Pokemon.remove({_id: '56f5ac6eddb43dbb52c3e58b'}).exec();
poke.then(success, failed);
function success(data) {
console.log(data);
}
function failed (err) {
console.log(err);
}
```
saida:
```js
node app.js
{ result: { ok: 1, n: 1 },
connection:
EventEmitter {
domain: null,
_events:
{ close: [Object],
error: [Object],
timeout: [Object],
parseError: [Object],
connect: [Function] },
_eventsCount: 5,
_maxListeners: undefined,
options:
{ socketOptions: {},
auto_reconnect: true,
host: 'localhost',
port: 27017,
cursorFactory: [Object],
reconnect: true,
emitError: true,
size: 5,
disconnectHandler: [Object],
bson: {},
messageHandler: [Function],
wireProtocolHandler: {} },
id: 0,
logger: { className: 'Connection' },
bson: {},
tag: undefined,
messageHandler: [Function],
maxBsonMessageSize: 67108864,
port: 27017,
host: 'localhost',
keepAlive: true,
keepAliveInitialDelay: 0,
noDelay: true,
connectionTimeout: 0,
socketTimeout: 0,
destroyed: false,
domainSocket: false,
singleBufferSerializtion: true,
serializationFunction: 'toBinUnified',
ca: null,
cert: null,
key: null,
passphrase: null,
ssl: false,
rejectUnauthorized: false,
checkServerIdentity: true,
responseOptions: { promoteLongs: true },
flushing: false,
queue: [],
connection:
Socket {
_connecting: false,
_hadError: false,
_handle: [Object],
_parent: null,
_host: 'localhost',
_readableState: [Object],
readable: true,
domain: null,
_events: [Object],
_eventsCount: 8,
_maxListeners: undefined,
_writableState: [Object],
writable: true,
allowHalfOpen: false,
destroyed: false,
bytesRead: 250,
_bytesDispatched: 226,
_sockname: null,
_pendingData: null,
_pendingEncoding: '',
_idleNext: null,
_idlePrev: null,
_idleTimeout: -1,
read: [Function],
_consuming: true },
writeStream: null,
hashedName: '29bafad3b32b11dc7ce934204952515ea5984b3c',
buffer: null,
sizeOfMessage: 0,
bytesRead: 0,
stubBuffer: null } }
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# NodeJS - Aula 07 - Exercício
**Autor**: Igor luíz
**Github**: [Halfeld](https://github.com/Halfeld)
**Data**: 1458281013095
## Crie um função que entenda de EventEmitter, nela crie um method, um chamado init, ele devera ser chamado toda vez que a sua função foi iniciada. Use o código 04 Como base.(use ele no prototype).
```js
'use strict';
const EventEmitter = require('events').EventEmitter,
util = require('util');
function Message(data) {
this.data = data;
this.on('show', show);
this.on('error', err);
EventEmitter.call(this);
}
Message.prototype.init = function() {
if(this.data) {
this.emit('show', this.data.name);
} else {
this.emit('error', new TypeError('No name'));
}
}
util.inherits(Message, EventEmitter);
function show(data) {
console.log(data);
}
function err(error) {
throw error;
}
const message = new Message({
name: 'Igor Luíz <Halfeld>'
});
message.init();
```
## Faça, um modulo simples para ler diretórios usando modulo FS(fs.readdir), usando o exemplo do código 03, esse modulo deve retornar uma Promise.
```js
'use strict';
const fs = require('fs');
function readDir(path) {
return new Promise( (resolve, reject) => {
fs.readdir(path, (err, data) => err ? reject(err) : resolve(data));
});
}
function readAll(arr) {
return Promise.all(arr)
.then(res => { return res })
.catch(err => { throw err });
}
readAll([
readDir('../event-emitter'),
readDir('../../class-5')
])
.then(res => console.log(res))
.catch(err => console.log(err));
```
## Os schemas do mongoose podem usar promises, em seus alguns methods, de “crud”, list 3 methods que usam promise , se chamada da função exec(), no final e 3 que usam exec(), mostre ao menos um exemplo de cada.
### Create
#### Código
```js
'use strict';
const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/peoples');
const Schema = mongoose.Schema;
const _schema = {
name: String,
age: Number,
height: Number
};
const User = mongoose.model('users', _schema);
// Create
let me = {
name: "Igor Luíz",
age: 17,
height: 1.97
}
User.create(me)
.then((data) => {
console.log(`Inseriu isso aí véi: ${data}`);
})
.catch(err => {
throw err ;
});
```
#### Saída no terminal
```sh
$ node createPromise.js
Inseriu isso aí véi: { _id: 56eb95a5c198f9200bec1134,
height: 1.97,
age: 17,
name: 'Igor Luíz',
__v: 0 }
```
### Find
#### Código
```js
'use strict';
const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/peoples');
const Schema = mongoose.Schema;
const _schema = {
name: String
};
const User = mongoose.model('users', _schema);
// Find
let query = { name: /igor luíz/i }
let result = User.find(query).exec();
result.then((data) => {
console.log(`Acho isso aí véi: ${data}`);
}).catch(err => {
throw err ;
});
```
#### Saída no terminal
```sh
$ node findPromise.js
Acho isso aí véi: { __v: 0,
height: 1.97,
age: 17,
name: 'Igor Luíz',
_id: 56eb95a5c198f9200bec1134 }
```
### Update
#### Código
```js
'use strict';
const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/peoples');
const Schema = mongoose.Schema;
const _schema = {
name: String
};
const User = mongoose.model('users', _schema);
// Update
let query = { name: /igor luíz/i },
mod = {name: "Igor Luíz | Halfeld"}
let result = User.update(query, mod).exec();
result.then((data) => {
console.log(data);
}).catch(err => {
throw err ;
});
```
#### Saída no terminal
```sh
$ node updatePromise.js
{ ok: 1, nModified: 1, n: 1 }
```
### Remove
#### Código
```js
'use strict';
const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/peoples');
const Schema = mongoose.Schema;
const _schema = {
name: String
};
const User = mongoose.model('users', _schema);
// Find
let query = {name: /igor luíz | halfeld/i }
let result = User.remove(query).exec();
result.then((data) => {
console.log(data);
}).catch(err => {
throw err ;
});
```
#### Saída no terminal
```sh
$ node deletePromise.js
{ ok: 1, nModified: 1, n: 1 }
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 07 - Exercício
**user:** [vitorcapretz](https://github.com/vitorcapretz)
**autor:** Vitor Capretz
**date:** 1468020913295
## 1. Crie um função que extenda EventEmitter, nela crie um method chamado init, ele deverá ser chamado toda vez que a sua função for iniciada. Use o código 04 como base (use ele no prototype).
* Código
```js
'use strict';
const EventEmitter = require('events').EventEmitter;
const util = require('util');
function User(data) {
this.data = data;
this.on('user:init', loginUser);
this.on('error', sendError);
EventEmitter.call(this);
};
util.inherits(User, EventEmitter);
User.prototype.init = function() {
if (this.data.name && this.data.pass) {
this.emit("user:init", this.data);
} else {
this.emit("error", new TypeError("Nome e senha requeridos!"));
}
};
function loginUser(user) {
util.log(`\n
\tUsuário ${user.name} logado com a senha ${user.pass}
\tParabéns.\n`);
}
function sendError(err) {
throw err;
}
const newUser = new User({'name': 'capretz', 'pass': 'forte'});
newUser.init();
```
* Retorno
```
vitor@vitor-ThinkPad-T440:/var/www/html/workshop-be-mean/nodejs/promises$ node ex1.js
8 Jul 20:43:01 -
Usuário capretz logado com a senha forte
Parabéns.
```
## 2. Faça um módulo simples para ler diretórios usando módulo FS (`fs.readdir`), usando o exemplo do código 03, esse módulo deve retornar uma Promise.
* Código
```js
"use strict";
const fs = require("fs");
function readDir(path) {
return new Promise((resolve, reject) => {
fs.readdir(path, "utf-8", function(err, res) {
err ? reject(err) : resolve(res);
});
});
}
module.exports = readDir;
```
* Código app.js
```js
"use strict";
const readDir = require("./module");
readDir("./resources").then(success, error);
function success(data) {
console.log(data);
}
function error(err) {
console.log(err);
}
```
* Retorno
```
node app.js
[ 'friends.json', 'people.json' ]
```
## 3. Os schemas do mongoose podem usar promises em seus methods de “crud”, liste 3 methods que usam `Promise` sem a chamada da função exec(), e no final e 3 que usam exec(), mostre ao menos um exemplo de cada.
* Código
```js
"use strict";
const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/be-mean-instagram');
const pokemonSchema = new mongoose.Schema({
name: String,
attack: Number,
defense: Number,
height: String,
types: [String],
created: {type: Date, default: Date.now}
});
const PokemonModel = mongoose.model('pokemons', pokemonSchema);
var pokemon = {
name: 'Capretzmon',
attack: 99,
defense: 99,
height: 1.7,
types: ['fire', 'poke']
};
PokemonModel.create(pokemon)
.then((data) => {
console.log('Pokemon created: ', data);
return PokemonModel.find({name: pokemon.name}).exec();
})
.then((data) => {
console.log('Pokemon found: ', data);
return PokemonModel.update({name: /nodemon/i}, {attack: 200});
})
.then((data) => {
console.log('Pokemon updated: ', data);
return PokemonModel.remove({name: /nodemon/i});
})
.then((data) => {
console.log('Pokemon removed: ', data);
})
.catch((err) => {
console.log(err);
});
```
* Retorno 1
```
Pokemon created: { __v: 0,
name: 'Capretzmon',
attack: 99,
defense: 99,
height: '1.7',
_id: 57803e148e09558831f21fa0,
created: 2016-07-08T23:58:12.917Z,
types: [ 'fire', 'poke' ] }
```
* Retorno 2
```
Pokemon found: [ { _id: 57803e148e09558831f21fa0,
name: 'Capretzmon',
attack: 99,
defense: 99,
height: '1.7',
__v: 0,
created: 2016-07-08T23:58:12.917Z,
types: [ 'fire', 'poke' ] } ]
```
* Retorno 3
```
Pokemon updated: { ok: 1, nModified: 0, n: 0 }
```
* Retorno 4
```
Pokemon removed: { result: { ok: 1, n: 0 },
connection:
EventEmitter {
domain: null,
_events:
{ close: [Object],
error: [Object],
timeout: [Object],
parseError: [Object],
connect: [Function] },
_eventsCount: 5,
_maxListeners: undefined,
options:
{ socketOptions: {},
auto_reconnect: true,
host: 'localhost',
port: 27017,
cursorFactory: [Object],
reconnect: true,
emitError: true,
size: 5,
disconnectHandler: [Object],
bson: {},
messageHandler: [Function],
wireProtocolHandler: {} },
id: 0,
logger: { className: 'Connection' },
bson: {},
tag: undefined,
messageHandler: [Function],
maxBsonMessageSize: 67108864,
port: 27017,
host: 'localhost',
keepAlive: true,
keepAliveInitialDelay: 0,
noDelay: true,
connectionTimeout: 0,
socketTimeout: 0,
destroyed: false,
domainSocket: false,
singleBufferSerializtion: true,
serializationFunction: 'toBinUnified',
ca: null,
cert: null,
key: null,
passphrase: null,
ssl: false,
rejectUnauthorized: false,
checkServerIdentity: true,
responseOptions: { promoteLongs: true },
flushing: false,
queue: [],
connection:
Socket {
connecting: false,
_hadError: false,
_handle: [Object],
_parent: null,
_host: 'localhost',
_readableState: [Object],
readable: true,
domain: null,
_events: [Object],
_eventsCount: 8,
_maxListeners: undefined,
_writableState: [Object],
writable: true,
allowHalfOpen: false,
destroyed: false,
_bytesDispatched: 791,
_sockname: null,
_pendingData: null,
_pendingEncoding: '',
server: null,
_server: null,
_idleNext: null,
_idlePrev: null,
_idleTimeout: -1,
read: [Function],
_consuming: true },
writeStream: null,
hashedName: '29bafad3b32b11dc7ce934204952515ea5984b3c',
buffer: null,
sizeOfMessage: 0,
bytesRead: 0,
stubBuffer: null } }
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 07 - Exercício
**user:** [carloshoribeiro](https://github.com/carloshoribeiro)
**autor:** Carlos Henrique Ribeiro
### 1 - Crie um função que entenda de EventEmitter, nela crie um method, um chamado init, ele devera ser chamado toda vez que a sua função foi iniciada. Use o código 04 Como base.(use ele no prototype).
#### ex1_init_event.js
```js
'use strict';
const EventEmitter = require('events').EventEmitter;
const util = require('util');
function CarlitoEmitter(data) {
this.data = data;
this.on('init', init);
EventEmitter.call(this);
}
CarlitoEmitter.prototype.init = function () {
this.emit('init', this.data);
};
util.inherits(CarlitoEmitter, EventEmitter);
function init (data) {
console.log('init =>', data.text);
}
module.exports = CarlitoEmitter;
```
#### ex1_init_event_main.js
```js
'use strict';
const CarlitoEmitter = require( './ex1_init_event.js' );
const myCarlitoEmitter = new CarlitoEmitter({ text: 'Carlitos'});
myBazingaEmitter.init();
```
#### Saída
```
$ node ex1_init_event_main.js
init => Carlitos
```
### 2 - Faça, um modulo simples para ler diretórios usando modulo FS(fs.readdir), usando o exemplo do código 03, esse modulo deve retornar uma Promise.
#### ex2_readdir_promise.js
```js
'use strict';
const fs = require('fs');
function readDir(path) {
return new Promise(function (resolve, reject) {
fs.readdir(path, function (err, res) {
err ? reject(err) : resolve(res);
});
});
}
module.exports = readDir;
```
#### ex2_readdir_promise_main.js
```js
'use strict';
const readDir = require('./ex2_readdir_promise.js');
function myPromiseAll(arr) {
return Promise.all(arr)
.then(result => { return result; })
.catch(err => { throw err; });
}
myPromiseAll([
readDir('../class07'),
readDir('../class02')
])
.then(result => console.log(result))
.catch(err => console.log(err));
```
### 3 - Os schemas do mongoose podem usar promises, em seus alguns methods, de “crud”, list 3 methods que usam promise , se chamada da função exec(), no final e 3 que usam exec(), mostre ao menos um exemplo de cada.
#### 3 - sem - `exec()`:
- `find`,
- `create`,
- `remove`
#### 3 - com - `exec()`:
- `find`,
- `findOne`,
- `update`
#### ex3_mongoose_promise.js
```js
'use strict';
// Conexão com o mongo
const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/be-mean-modulo-nodejs-exercises');
// Definição do Schema
const Schema = mongoose.Schema;
const bandsSchema = new Schema({
name: String
});
// Definição do Model
const BandsModel = mongoose.model('bands', bandsSchema);
const band1 = {
name: 'Manonas assassinas'
};
// 3 métodos - sem exec()
const findPromise = BandsModel.find({name: 'Linkin Park'});
findPromise.then(success, error);
// [ { name: 'Linkin Park', _id: 56ff424dcb3f181e1d0ae7a6 } ]
const createPromise = BandsModel.create(band1)
createPromise.then(success , error);
// { _id: 56ff4d03d20057e62669be34, name: 'Manonas assassinas', __v: 0 }
const removePromise = BandsModel.remove({name : band1.name });
removePromise.then(success , error);
// result: { ok: 1, n: 1 }
// 3 métodos - com exec()
const findPromiseExec = BandsModel.find({name: 'Ramones'}).exec();
findPromiseExec.then(success, error);
//[ { name: 'Ramones', _id: 56ff422bcb3f181e1d0ae7a5 } ]
const findOnepromise = BandsModel.findOne({ name: 'Metallica' }).exec();
findOnepromise.then(success , error);
//{ name: 'Metallica', _id: 56ff3ef8cb3f181e1d0ae7a4 }
const updatePromise = BandsModel.update({ name : 'Metallica'}, {name: '+Metallica'}).exec();
updatePromise.then(success , error);
//{ ok: 1, nModified: 1, n: 1 }
function success(data) {
console.log(data);
}
function error (err) {
console.log(err);
}
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 07 - Exercício
**user**: [xereda](https://github.com/xereda)
**autor**: Jackson Ricardo Schroeder
**date**: 1466134880357
# Crie um função que entenda de EventEmitter. Nela crie um method chamado init. Ele devera ser chamado toda vez que a sua função for iniciada. Use o código 04 como base.(use ele no prototype).
## model.js
```js
"use strict";
const EventEmitter = require("events").EventEmitter;
const util = require("util");
function User(data) {
this.data = data;
this.on("user:init", sendMail);
this.on("error", sendError);
EventEmitter.call(this);
}
util.inherits(User, EventEmitter);
User.prototype.init = function() {
if (this.data.name) {
this.emit("user:init", this.data);
} else {
this.emit("error", new TypeError("Usuário precisa de um nome!"));
}
}
function sendMail(user) {
user.pass = Math.floor(Math.random() * 10000);
//console.log(`${user.pass}`);
util.log(`\n
\tOlá ${user.name}!
\tEstamos inicializando seu perfil em nosso sistema.
\tSeja bem vindo. Seu pass é ${user.pass}.
\tVocê tem 24 horas para alterá-lo ou terá que solicitar reenvio.\n`);
}
function sendError(err) {
throw err;
}
module.exports = User;
```
## app.js
```js
"use strict";
const User = require("./model");
const user = new User({name: "Jackson"});
user.init();
```
## resultado
```
node app.js
16 Jun 23:55:23 -
Olá Jackson!
Estamos inicializando seu perfil em nosso sistema.
Seja bem vindo. Seu pass é 148.
Você tem 24 horas para alterá-lo ou terá que solicitar reenvio.
```
# Faça, um modulo simples para ler diretórios usando modulo FS(fs.readdir), usando o exemplo do código 03, esse modulo deve retornar uma Promise.
## module.js
```js
"use strict";
const fs = require("fs");
function readDir(path) {
return new Promise(function(resolve, reject) {
fs.readdir(path, "utf-8", function(err, res) {
err ? reject(err) : resolve(res);
});
});
}
module.exports = readDir;
```
## app.js
```js
"use strict";
const readDir = require("./module");
readDir("./../../").then(sucess, error);
function sucess(data) {
console.log(data);
}
function error(err) {
console.log(err);
}
```
## Saída:
```
node app.js
[ 'closures',
'emiter.js',
'emiter2.js',
'events.js',
'exercicios',
'heranca',
'promise',
'resources' ]
```
# Os schemas do mongoose podem usar promises, em alguns de seus method de “crud”, list 3 methods que usam promise , se chamada da função exec(), no final e 3 que usam exec(), mostre ao menos um exemplo de cada.
## model/pokemon.js
```js
"use strict";
const mongoose = require("mongoose");
const util = require("util");
function pokemonHadler() {
let Schema = mongoose.Schema;
const schema = new Schema({
name: { type: String, required: "Nome é obrigatório!" },
attack: { type: Number },
created: { type: Date, default: Date.now },
defense: { type: Number},
height: { type: String },
speed: { type: Number },
types: [String]
});
schema.pre("find", function(next) {
this.start = Date.now();
util.log("[EVENTO PRE FIND] ... ");
next();
});
schema.post("find", function(result) {
setTimeout(function() {
console.log("[EVENTO POST FIND] ...");
}, 0);
});
return mongoose.model("Pokemon", schema);
}
module.exports = exports = pokemonHadler();
```
## app-promise-find.js
```js
"use strict";
const mongoose = require("mongoose");
mongoose.connect("mongodb://localhost/be-mean-instagram");
const Pokemon = require("./models/pokemon");
let promise = Pokemon.find({name: /charizard-mega-x/i }).exec();
promise.then(sucess, error);
function sucess(data) {
console.log(data);
}
function error(err) {
console.log(err);
}
```
## Saída:
```
node app-promise-find.js
17 Jun 00:24:03 - [EVENTO PRE FIND] ...
[ { created: 2013-11-03T15:05:42.539Z,
types: [ 'fire', 'dragon' ],
speed: 100,
name: 'Charizard-mega-x',
hp: 78,
height: '0',
defense: 111,
attack: 130,
_id: 564b1de625337263280d06b9 } ]
[EVENTO POST FIND] ...
```
## app-promise-findOne.js
```js
"use strict";
const mongoose = require("mongoose");
mongoose.connect("mongodb://localhost/be-mean-instagram");
const Pokemon = require("./models/pokemon");
let promise = Pokemon.findOne({name: /charizard /i }).exec();
promise.then(sucess, error);
function sucess(data) {
console.log(data);
}
function error(err) {
console.log(err);
}
```
## Saída:
```
node app-promise-findOne.js
{ created: 2013-11-03T15:05:41.275Z,
types: [ 'flying', 'fire' ],
speed: 100,
name: 'Charizard',
hp: 78,
height: '17',
defense: 78,
attack: 84,
_id: 564b1de325337263280d068d }
```
## app-promise-remove
```js
"use strict";
const mongoose = require("mongoose");
mongoose.connect("mongodb://localhost/be-mean-instagram");
const Pokemon = require("./models/pokemon");
let promise = Pokemon.remove({name: /charizard/i }).exec();
promise.then(sucess, error);
function sucess(data) {
console.log(data);
}
function error(err) {
console.log(err);
}
```
## Saída:
```
node app-promise-remove.js
{ result: { ok: 1, n: 3 },
connection:
EventEmitter {
domain: null,
_events:
{ close: [Object],
error: [Object],
timeout: [Object],
parseError: [Object],
connect: [Function] },
_eventsCount: 5,
_maxListeners: undefined,
options:
{ socketOptions: {},
auto_reconnect: true,
host: 'localhost',
port: 27017,
cursorFactory: [Object],
reconnect: true,
emitError: true,
size: 5,
disconnectHandler: [Object],
bson: {},
messageHandler: [Function],
wireProtocolHandler: [Object] },
id: 0,
logger: { className: 'Connection' },
bson: {},
tag: undefined,
messageHandler: [Function],
maxBsonMessageSize: 67108864,
port: 27017,
host: 'localhost',
keepAlive: true,
keepAliveInitialDelay: 0,
noDelay: true,
connectionTimeout: 0,
socketTimeout: 0,
destroyed: false,
domainSocket: false,
singleBufferSerializtion: true,
serializationFunction: 'toBinUnified',
ca: null,
cert: null,
key: null,
passphrase: null,
ssl: false,
rejectUnauthorized: false,
checkServerIdentity: true,
responseOptions: { promoteLongs: true },
flushing: false,
queue: [],
connection:
Socket {
connecting: false,
_hadError: false,
_handle: [Object],
_parent: null,
_host: 'localhost',
_readableState: [Object],
readable: true,
domain: null,
_events: [Object],
_eventsCount: 8,
_maxListeners: undefined,
_writableState: [Object],
writable: true,
allowHalfOpen: false,
destroyed: false,
_bytesDispatched: 227,
_sockname: null,
_pendingData: null,
_pendingEncoding: '',
server: null,
_server: null,
_idleNext: null,
_idlePrev: null,
_idleTimeout: -1,
read: [Function],
_consuming: true },
writeStream: null,
hashedName: '29bafad3b32b11dc7ce934204952515ea5984b3c',
buffer: null,
sizeOfMessage: 0,
bytesRead: 0,
stubBuffer: null } }
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 07 - Exercício
**User:** [Cerezini](https://github.com/Cerezini)
**Autor:** Mateus Cerezini Gomes
## 1. Crie um função que extenda EventEmitter, nela crie um method chamado init, ele deverá ser chamado toda vez que a sua função for iniciada. Use o código 04 como base (use ele no prototype).
```js
'use strict';
const EventEmitter = require('events').EventEmitter;
const util = require('util');
function Potato() {
this.on('event:init', init);
EventEmitter.call(this);
}
util.inherits(Potato, EventEmitter);
Potato.prototype.init = function () {
this.emit('event:init');
};
function init() {
console.log('Objeto Potato iniciado');
}
// Executando
var potato = new Potato();
potato.init();
```
```shell
Objeto potato iniciado
```
## 2. Faça um módulo simples para ler diretórios usando módulo FS (fs.readdir), usando o exemplo do código 03, esse modulo deve retornar uma Promise.
```js
'use strict';
const fs = require('fs');
function readDir(path) {
return new Promise( function (resolve, reject) {
fs.readdir(path, function (err, data) {
err ? reject(err) : resolve(data);
});
});
}
// Executing
readDir('node_modules').then(function (data) {
console.log(data);
}).catch(function (err) {
console.log(err);
});
// Test error
readDir('modules').then(function (data) {
console.log(data);
}).catch(function (err) {
console.log(err);
});
```
```shell
[ '.bin',
'async',
'bluebird',
'bson',
'core-util-is',
'debug',
'es6-promise',
'hooks-fixed',
'inherits',
'isarray',
'kareem',
'mongodb',
'mongodb-core',
'mongoose',
'mpath',
'mpromise',
'mquery',
'ms',
'muri',
'readable-stream',
'regexp-clone',
'require_optional',
'resolve-from',
'semver',
'sliced',
'string_decoder' ]
{ [Error: ENOENT: no such file or directory, scandir 'modules'] errno: -2, code: 'ENOENT', syscall: 'scandir', path: 'modules' }
```
## 3. Os schemas do mongoose podem usar promises, em seus alguns methods, de “crud”, liste 3 methods que usam promise, se chamada da função exec(), no final e 3 que usam exec(), mostre ao menos um exemplo de cada.
```js
'use strict';
const mongoose = require('mongoose');
// Connect to MongoDb
mongoose.connect('mongodb://localhost/be-mean-instagram');
// Create Pokemon Model
const pokemonSchema = new mongoose.Schema({
name: String,
attack: Number,
defense: Number,
hp: Number,
speed: Number,
height: String,
types: [String],
created: {type: Date, default: Date.now}
});
const PokemonModel = mongoose.model('pokemons', pokemonSchema);
// Executing
var pokemon = {
name: 'Nodemon',
attack: 100,
defense: 100,
hp: 5000,
speed: 100,
height: 3,
types: ['fire', 'mean']
};
PokemonModel.create(pokemon) //Create
.then((data) => {
console.log('Created: ', data);
return PokemonModel.find({name: pokemon.name}).exec(); //Find
})
.then((data) => {
console.log('Found: ', data);
return PokemonModel.update({name: /nodemon/i}, {attack: 200}); //Update
})
.then((data) => {
console.log('Updated: ', data);
return PokemonModel.remove({name: /nodemon/i}); //Remove
})
.then((data) => {
console.log('Removed: ', data);
})
.catch((err) => {
console.log(err);
});
```
```shell
Created: { types: [ 'fire', 'mean' ],
created: Thu Apr 14 2016 01:05:49 GMT-0300 (BRT),
_id: 570f171d3493e0f51df0649a,
height: '3',
speed: 100,
hp: 5000,
defense: 100,
attack: 100,
name: 'Nodemon',
__v: 0 }
Found: [ { types: [ 'fire', 'mean' ],
created: Thu Apr 14 2016 01:05:49 GMT-0300 (BRT),
__v: 0,
height: '3',
speed: 100,
hp: 5000,
defense: 100,
attack: 100,
name: 'Nodemon',
_id: 570f171d3493e0f51df0649a } ]
Updated: { ok: 1, nModified: 1, n: 1 }
Removed: { result: { ok: 1, n: 1 }
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 07 - Exercício
**user:** [tuchedsf](https://github.com/tuchedsf)
**autor:** Diego Ferreira
## 1 - Crie um função que entenda de EventEmitter, nela crie um method, um chamado init, ele devera ser chamado toda vez que a sua função foi iniciada. Use o código 04 como base (use ele no prototype).
```js
'use strinct';
//declarando modulo events/eventemitter
const EventEmitter = require('events').EventEmitter;
//requendo modulo util para implementaçao herança Prototype
const util = require('util');
//definindo função com os metodos de disparo do eventEmitter
function Autenticar(data) {
this.data = data;
this.on('autenticar.init', sendMessageOK);
this.on('error', sendError);
EventEmitter.call(this);
}
//instanciando prototype
Autenticar.prototype.init = function () {
if (this.data.login){
this.emit('autenticar.init', this.data);
} else {
this.emit('error', new TypeError('Erro ao autenticar o usuário'));
}
}
//utilizando o uitl para fazer a herança, dizendo que antenticar é um tipo de eventEmitter.
util.inherits(Autenticar, EventEmitter);
function sendMessageOK(data) {
console.log(data.login);
}
function sendError( err ) {
throw err;
}
//Uso passando um login como parametro
const message = new Autenticar({login: 'tuchedsf'});
message.init();
```
Saída no terminal:
```
diego@MacBook-Air-Diego ~/M/n/7EventPromisses> node eventsEmitter.js
tuchedsf
```
## 2 - Faça, um modulo simples para ler diretórios usando modulo FS(fs.readdir), usando o exemplo do código 03, esse modulo deve retornar uma Promise.
Módulo ler diretórios:fs-readdir.js
```js
'use strict';
const fs = require('fs');
function readDir (path) {
return new Promise(function(resolve, reject) {
fs.readdir(path,function(err, files) {
err ? reject(err) : resolve(files);
});
});
}
module.exports = readDir;
```
Uso do módulo:
```js
'use strict';
const readDir = require('./fs-readdir');
let dir = '../filesync/dirNode2';
readDir(dir).then(success , error);
function success (data) {
console.log(data);
}
function error (err) {
console.error(err);
}
```
Resultado:
```
diego@MacBook-Air-Diego ~/M/n/7EventPromisses> node fs-readDir-call.js
[ 'helloWorld.txt', 'hiWorld.txt' ]
```
## 3 - Os schemas do mongoose podem usar promises, em alguns dos seus methods, de “crud”, list 3 methods que usam promise , sem chamada da função exec(), no final e 3 que usam exec(), mostre ao menos um exemplo de cada.
- Métodos sem chamada a exec()
+ create
+ remove
+ find //sem exec
- Métodos com chamada exec()
+ update
+ find //com exec
+ findOne
- Arquivo definição Modelo
+ PokemonModel
```js
'use strict';
const mongoose = require('mongoose');
const uriDB = 'mongodb://localhost/be-mean-instagram';
//criar uma conexão com mongo
mongoose.connect(uriDB);
const _schema = {
name: {type : String, required:true},
description: {type: String, minlength : 5, maxlength : 50},
attack: {type: Number, min: 40, max: 95},
defense : {type : Number, match: /\d/g },
height : Number,
cor: {type: String, enum: ['Red', 'Blue', 'Green'], required:true},
created_at: { type: Date, default: Date.now }
}
const PokemonSchema = new mongoose.Schema(_schema);
const PokemonModel = mongoose.model('pokemons', PokemonSchema);
module.exports = PokemonModel;
```
+ Create
```js
'use strict';
const pokemonModel = require('./PokemonsModel.js');
const pokemon = {
name: "Poke Promisse",
description: "Pokemon criador de promisses",
attack: 95,
defense : 84,
height : 2,
cor: 'Blue'
};
pokemonModel.create(pokemon).then(success , error);
function success(data) {
console.log(data);
}
function error (err) {
console.log(err);
}
```
Resultado:
```
diego@MacBook-Air-Diego ~/M/n/7EventPromisses> node createPoke_promisse.js
{ created_at: Sun May 08 2016 11:16:34 GMT-0300 (BRT),
_id: 572f4a42cf4c206bfcaa7480,
cor: 'Blue',
height: 2,
defense: 84,
attack: 95,
description: 'Pokemon criador de promisses',
name: 'Poke Promisse',
__v: 0 }
```
+ remove
```js
'use strict';
const pokemonModel = require('./PokemonsModel.js');
const query = {"_id" : "572f4a42cf4c206bfcaa7480"}
pokemonModel.remove(query).then(success , error);
function success(data) {
console.log(data);
}
function error (err) {
console.log(err);
}
```
Resultado
```
diego@MacBook-Air-Diego ~/M/n/7EventPromisses> node remove_promise.js
{ result: { ok: 1, n: 1 },
connection:
EventEmitter {
domain: null,
_events:
{ close: [Object],
error: [Object],
timeout: [Object],
parseError: [Object],
connect: [Function] },
_eventsCount: 5,
_maxListeners: undefined,
options:
{ socketOptions: {},
auto_reconnect: true,
host: 'localhost',
port: 27017,
cursorFactory: [Object],
reconnect: true,
emitError: true,
size: 5,
disconnectHandler: [Object],
bson: {},
messageHandler: [Function],
wireProtocolHandler: [Object] },
id: 0,
logger: { className: 'Connection' },
bson: {},
tag: undefined,
messageHandler: [Function],
maxBsonMessageSize: 67108864,
port: 27017,
host: 'localhost',
keepAlive: true,
keepAliveInitialDelay: 0,
noDelay: true,
connectionTimeout: 0,
socketTimeout: 0,
destroyed: false,
domainSocket: false,
singleBufferSerializtion: true,
serializationFunction: 'toBinUnified',
ca: null,
cert: null,
key: null,
passphrase: null,
ssl: false,
rejectUnauthorized: false,
checkServerIdentity: true,
responseOptions: { promoteLongs: true },
flushing: false,
queue: [],
connection:
Socket {
_connecting: false,
_hadError: false,
_handle: [Object],
_parent: null,
_host: 'localhost',
_readableState: [Object],
readable: true,
domain: null,
_events: [Object],
_eventsCount: 8,
_maxListeners: undefined,
_writableState: [Object],
writable: true,
allowHalfOpen: false,
destroyed: false,
bytesRead: 250,
_bytesDispatched: 226,
_sockname: null,
_pendingData: null,
_pendingEncoding: '',
_idleNext: null,
_idlePrev: null,
_idleTimeout: -1,
read: [Function],
_consuming: true },
writeStream: null,
hashedName: '29bafad3b32b11dc7ce934204952515ea5984b3c',
buffer: null,
sizeOfMessage: 0,
bytesRead: 0,
stubBuffer: null } }
```
+ find //sem exec
```js
'use strict';
const pokemonModel = require('./PokemonsModel.js');
const query = {$and :[{attack : 40}, {defense : 40}]}
pokemonModel.find(query).then(success,error);
function success(data) {
console.log(data);
}
function error (err) {
console.log(err);
}
```
Resultado
```
diego@MacBook-Air-Diego ~/M/n/7EventPromisses> node find_promise.js
[ { created_at: Sun May 08 2016 11:58:03 GMT-0300 (BRT),
cor: 'Blue',
height: 0.7,
defense: 40,
attack: 40,
description: 'Pokemon que altera inserindo',
name: 'Nerdmon',
_id: 57294fe05daea5abb1cb1c4f } ]
```
+ update
```js
'use strict';
const pokemonModel = require('./PokemonsModel.js');
const query = {"_id" : "572f4a42cf4c206bfcaa7480"}
const mod = {name: "Poke Promise", defense : 50}
let promise = pokemonModel.update(query,mod).exec();
promise.then(success, error);
function success(data) {
console.log(data);
}
function error (err) {
console.log(err);
}
```
Resultado
```
diego@MacBook-Air-Diego ~/M/n/7EventPromisses> node update_promise.js
{ ok: 1, nModified: 1, n: 1 }
```
+ findOne
```js
'use strict';
const pokemonModel = require('./PokemonsModel.js');
let promise = pokemonModel.findOne({}).exec();
promise.then(success, error);
function success(data) {
console.log(data);
}
function error (err) {
console.log(err);
}
```
Resultado
```
iego@MacBook-Air-Diego ~/M/n/7EventPromisses> node find_promise.js
{ created_at: Sun May 08 2016 11:43:51 GMT-0300 (BRT),
__v: 0,
attack: 0,
height: 20,
defense: 75,
type: 'reptile',
description: 'Tartaruga tuche',
name: 'Tuchemon',
_id: 57256689b8b229d6b6b14df7 }
```
+ find
```js
'use strict';
const pokemonModel = require('./PokemonsModel.js');
const query = {defense : {$lt: 90}}
let promise = pokemonModel.find(query).exec();
promise.then(success, error);
function success(data) {
console.log(data);
}
function error (err) {
console.log(err);
}
```
Resultado
```
diego@MacBook-Air-Diego ~/M/n/7EventPromisses> node find_promise.js
[ { created_at: Sun May 08 2016 11:46:04 GMT-0300 (BRT),
__v: 0,
attack: 0,
height: 20,
defense: 30,
type: 'reptile',
description: 'Tartaruga tuche',
name: 'Tuchemon',
_id: 57256bacb6315cbdb70fc87e },
{ created_at: Tue May 03 2016 22:09:51 GMT-0300 (BRT),
__v: 0,
cor: 'Green',
height: 0.4,
defense: 30,
attack: 40,
description: 'Pokemon especialista em grama',
name: 'Gramosauro',
_id: 57294bdfb6de032bd6811516 },
{ created_at: Sun May 08 2016 11:46:04 GMT-0300 (BRT),
cor: 'Blue',
height: 0.7,
defense: 40,
attack: 40,
description: 'Pokemon que altera inserindo',
name: 'Nerdmon',
_id: 57294fe05daea5abb1cb1c4f } ]
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 07 - Exercício
**user:** [fauker](http://github.com/fauker)
**autor:** LUCAS DA SILVA MOREIRA
1 - Crie um função que entenda de EventEmitter, nela crie um method, um chamado init, ele devera ser chamado toda vez que a sua função foi iniciada. Use o código 04 Como base.(use ele no prototype).
```
var EventEmitter = require('events').EventEmitter;
var util = require('util');
function User(data) {
this.name = data.name;
this.on('user:init', sayName);
EventEmitter.call(this);
};
util.inherits(User, EventEmitter);
User.prototype.init = function() {
this.emit('user:init', this.name);
};
function sayName(name) {
console.log('Iniciando... Olá, humano! Você me deu o nome de', name);
};
var User = new User({name: 'Lucas'});
User.init();
```
Resultado:
```
node arquivos/events-e-promise/eventEmitter.js
Iniciando... Olá, humano! Você me deu o nome de Lucas
```
2 - Faça, um modulo simples para ler diretórios usando modulo FS(fs.readdir), usando o exemplo do código 03, esse modulo deve retornar uma Promise.
```
var fs = require('fs');
function readdir(path) {
return new Promise(function(resolve, reject) {
fs.readdir(path,function(err, res) {
err ? reject(err) : resolve(res);
});
});
};
readdir('.').then(function(data) {
console.log('Arquivos:', data);
}, function(error) {
console.log('ERROR', error);
});
```
Resultado:
```
node readDirPromise.js
Arquivos: [ 'arquivo.txt', 'eventEmitter.js', 'readDirPromise.js' ]
```
3 - Os schemas do mongoose podem usar promises, em seus alguns methods, de “crud”, list 3 methods que usam promise , se chamada da função exec(), no final e 3 que usam exec(), mostre ao menos um exemplo de cada.
Schema
```
var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost:27017/be-mean-instagram', function() {
console.log('MongoDB conectado!');
});
var Schema = mongoose.Schema;
var _schema = {
name: String,
description: String,
type: String,
attack: Number,
defense: Number,
height: Number
};
var pokemonSchema = new Schema(_schema);
var Pokemon = mongoose.model('Pokemon', pokemonSchema);
module.exports = Pokemon;
```
find
```
var mongoose = require('mongoose');
var Pokemon = require('./pokemon');
var promise = Pokemon.find({name: /nerdmon/i}).exec();
promise.then(function(data) {
console.log(data);
}, function(error) {
console.log(data);
});
node findPromise.js
MongoDB conectado!
[ { height: 100,
defense: 50,
attack: 49,
type: 'fogo',
description: 'Pokemon mt nerd',
name: 'Nerdmon',
_id: 57297a013b4cb9a31a868f50 } ]
```
findOne
```
var mongoose = require('mongoose');
var Pokemon = require('./pokemon');
var promise = Pokemon.findOne({_id: "57297a013b4cb9a31a868f50"}).exec();
promise.then(function(data) {
console.log(data);
}, function(error) {
console.log(data);
});
node findOnePromise.js
MongoDB conectado!
{ height: 100,
defense: 50,
attack: 49,
type: 'fogo',
description: 'Pokemon mt nerd',
name: 'Nerdmon',
_id: 57297a013b4cb9a31a868f50 }
```
remove
```
var mongoose = require('mongoose');
var Pokemon = require('./pokemon');
var promise = Pokemon.remove({_id: "57297a013b4cb9a31a868f50"}).exec();
promise.then(function(data) {
console.log(data);
}, function(error) {
console.log(data);
});
node removePromise.js
MongoDB conectado!
{ result: { ok: 1, n: 1 },
connection:
EventEmitter {
domain: null,
_events:
{ close: [Object],
error: [Object],
timeout: [Object],
parseError: [Object],
connect: [Function] },
_eventsCount: 5,
_maxListeners: undefined,
options:
{ socketOptions: {},
auto_reconnect: true,
host: 'localhost',
port: 27017,
cursorFactory: [Object],
reconnect: true,
emitError: true,
size: 5,
disconnectHandler: [Object],
bson: {},
messageHandler: [Function],
wireProtocolHandler: [Object] },
id: 0,
logger: { className: 'Connection' },
bson: {},
tag: undefined,
messageHandler: [Function],
maxBsonMessageSize: 67108864,
port: 27017,
host: 'localhost',
keepAlive: true,
keepAliveInitialDelay: 0,
noDelay: true,
connectionTimeout: 0,
socketTimeout: 0,
destroyed: false,
domainSocket: false,
singleBufferSerializtion: true,
serializationFunction: 'toBinUnified',
ca: null,
cert: null,
key: null,
passphrase: null,
ssl: false,
rejectUnauthorized: false,
checkServerIdentity: true,
responseOptions: { promoteLongs: true },
flushing: false,
queue: [],
connection:
Socket {
_connecting: false,
_hadError: false,
_handle: [Object],
_parent: null,
_host: 'localhost',
_readableState: [Object],
readable: true,
domain: null,
_events: [Object],
_eventsCount: 8,
_maxListeners: undefined,
_writableState: [Object],
writable: true,
allowHalfOpen: false,
destroyed: false,
bytesRead: 250,
_bytesDispatched: 226,
_sockname: null,
_pendingData: null,
_pendingEncoding: '',
_idleNext: null,
_idlePrev: null,
_idleTimeout: -1,
read: [Function],
_consuming: true },
writeStream: null,
hashedName: '29bafad3b32b11dc7ce934204952515ea5984b3c',
buffer: null,
sizeOfMessage: 0,
bytesRead: 0,
stubBuffer: null } }
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 07 - Exercício
**User:** [gkal19](https://github.com/gkal19)
**Autor:** Gabriel Kalani
**Data:** 1465801860
## Índice
##### [Exercício-01](#1-crie-um-função-que-extenda-eventemitter-nela-crie-um-method-chamado-init-ele-deverá-ser-chamado-toda-vez-que-a-sua-função-for-iniciada-use-o-código-04-como-base-use-ele-no-prototype)
* [Resultado 01](#resultado-01)
##### [Exercício-02](#2-faça-um-módulo-simples-para-ler-diretórios-usando-módulo-fs-fsreaddir-usando-o-exemplo-do-código-03-esse-modulo-deve-retornar-uma-promise)
* [Resultado 02](#resultado-02)
##### [Exercício-03](#3-os-schemas-do-mongoose-podem-usar-promises-em-seus-alguns-methods-de-crud-liste-3-methods-que-usam-promise-se-chamada-da-função-exec-no-final-e-3-que-usam-exec-mostre-ao-menos-um-exemplo-de-cada)
* [Resultado 03](#resultado-03)
<br>
## 1. Crie um função que extenda EventEmitter, nela crie um method chamado init, ele deverá ser chamado toda vez que a sua função for iniciada. Use o código 04 como base (use ele no prototype).
```js
const EventEmitter = require('events').EventEmitter;
const util = require('util');
class User {
constructor(data) {
this.name = data.name;
this.on('user:init', Name);
EventEmitter.call(this);
}
init() {
this.emit('user:init', this.name);
}
}
util.inherits(User, EventEmitter);
function Name(name) {
console.log('Tá tranquilo, tá compilado. Meu nome é MC', name);
}
const User = new User({name: 'Pokémon'});
User.init();
```
## Resultado 01
```shell
$ node rogue.js
Tá tranquilo, tá compilado. Meu nome é MC Pokémon
```
## 2. Faça um módulo simples para ler diretórios usando módulo FS (fs.readdir), usando o exemplo do código 03, esse modulo deve retornar uma Promise.
```js
'use strict';
const fs = require('fs');
function readDir(path) {
return new Promise( (resolve, reject) => {
fs.readdir(path, (err, data) => {
err ? reject(err) : resolve(data);
});
});
}
// Executando
readDir('node_modules').then(data => {
console.log(data);
}).catch(err => {
console.log(err);
});
```
## Resultado 02
```shell
$ node rogue.js
[ 'mongoose' ]
```
## 3. Os schemas do mongoose podem usar promises, em seus alguns methods, de “crud”, liste 3 methods que usam promise, se chamada da função exec(), no final e 3 que usam exec(), mostre ao menos um exemplo de cada.
```js
'use strict';
const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/be-mean-instagram');
// Aqui criarei um schema de um Pokémon
const pokemonSchema = new mongoose.Schema({
name: String,
attack: Number,
defense: Number,
hp: Number,
speed: Number,
height: String,
types: [String],
created: {type: Date, default: Date.now}
});
const PokemonModel = mongoose.model('pokemons', pokemonSchema);
// Aqui está os dados do schema do meu Pokémon
const pokemon = {
name: 'Bulbasaur',
attack: 100,
defense: 100,
hp: 5000,
speed: 100,
height: 3,
types: ['fire', 'poke']
};
PokemonModel.create(pokemon)
// Create
.then((data) => {
console.log('Foi criado: ', data);
return PokemonModel.find({name: pokemon.name}).exec();
})
// Find
.then((data) => {
console.log('Foi Encontrado: ', data);
return PokemonModel.update({name: /nodemon/i}, {attack: 200});
})
// Update
.then((data) => {
console.log('Foi atualizado: ', data);
return PokemonModel.remove({name: /nodemon/i});
})
// Remove
.then((data) => {
console.log('Foi removido: ', data);
})
.catch((err) => {
console.log(err);
});
```
## Resultado 03
```shell
Foi criado: { types: [ 'fire', 'poke' ],
created: Sat Jun 11 2016 11:47:07 GMT+0000 (UTC),
_id: 575bfa3b824396e6061182e5,
height: '3',
speed: 100,
hp: 5000,
defense: 100,
attack: 100,
name: 'Bulbasaur',
__v: 0 }
Foi Encontrado: [ { types: [ 'fire', 'poke' ],
created: Sat Jun 11 2016 11:47:07 GMT+0000 (UTC),
__v: 0,
height: '3',
speed: 100,
hp: 5000,
defense: 100,
attack: 100,
name: 'Bulbasaur',
_id: 575bfa3b824396e6061182e5 } ]
Foi atualizado: { ok: 1, nModified: 0, n: 0 }
Foi removido: { result: { ok: 1, n: 0 },
connection:
EventEmitter {
domain: null,
_events:
{ close: [Object],
error: [Object],
timeout: [Object],
parseError: [Object],
connect: [Function] },
_eventsCount: 5,
_maxListeners: undefined,
options:
{ socketOptions: {},
auto_reconnect: true,
host: 'localhost',
port: 27017,
cursorFactory: [Object],
reconnect: true,
emitError: true,
size: 5,
disconnectHandler: [Object],
bson: {},
messageHandler: [Function],
wireProtocolHandler: {} },
id: 0,
logger: { className: 'Connection' },
bson: {},
tag: undefined,
messageHandler: [Function],
maxBsonMessageSize: 67108864,
port: 27017,
host: 'localhost',
keepAlive: true,
keepAliveInitialDelay: 0,
noDelay: true,
connectionTimeout: 0,
socketTimeout: 0,
destroyed: false,
domainSocket: false,
singleBufferSerializtion: true,
serializationFunction: 'toBinUnified',
ca: null,
cert: null,
key: null,
passphrase: null,
ssl: false,
rejectUnauthorized: false,
checkServerIdentity: true,
responseOptions: { promoteLongs: true },
flushing: false,
queue: [],
connection:
Socket {
_connecting: false,
_hadError: false,
_handle: [Object],
_parent: null,
_host: 'localhost',
_readableState: [Object],
readable: true,
domain: null,
_events: [Object],
_eventsCount: 8,
_maxListeners: undefined,
_writableState: [Object],
writable: true,
allowHalfOpen: false,
destroyed: false,
bytesRead: 575,
_bytesDispatched: 806,
_sockname: null,
_pendingData: null,
_pendingEncoding: '',
_idleNext: null,
_idlePrev: null,
_idleTimeout: -1,
read: [Function],
_consuming: true },
writeStream: null,
hashedName: '29bafad3b32b11dc7ce934204952515ea5984b3c',
buffer: null,
sizeOfMessage: 0,
bytesRead: 0,
stubBuffer: null } }
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 07 - Exercício
**User:** [matheusjkweber](https://github.com/matheusjkweber)
**Autor:** Matheus José Krumenauer Weber
**Date:** 1457290593512
## Crie um função que entenda de EventEmitter, nela crie um method, um chamado init, ele devera ser chamado toda vez que a sua função foi iniciada. Use o código 04 Como base.(use ele no prototype).
```js
'use strict';
const EventEmitter = require('events').EventEmitter;
const util = require('util');
function Foo(data) {
this.data = data;
this.on('foo:init', sendAlert);
this.on('error', sendError);
EventEmitter.call(this);
}
util.inherits(Foo, EventEmitter);
Foo.prototype.init = function () {
if(this.data.msg){
this.emit('foo:init',sendAlert);
}
else {
this.emit('error', new TypeError('Write an alert!'));
}
};
function sendAlert(data) {
console.log("Is working! Msg: "+this.data.msg);
}
function sendError(err) {
throw err;
}
module.exports = Foo;
```
```js
'use strict';
const Foo = require('./exercicio_aula7_1.js');
const foo = new Foo({ msg : 'Message passed!'});
foo.init();
matheus@Math:~/Desktop/Desenvolvimento/workshop-be-mean/nodejs/class6$ node exercicio_aula7_1_2.js
Is working! Msg: Message passed!
```
## Faça, um modulo simples para ler diretórios usando modulo FS(fs.readdir), usando o exemplo do código 03, esse modulo deve retornar uma Promise.
```js
'use strict';
const fs = require('fs');
function readDirectory (path) {
return new Promise(function(resolve, reject) {
fs.readdir(path,function(err, res) {
err ? reject(err) : resolve(res);
});
});
}
module.exports = readDir;
```
```js
'use strict';
function promiseAll (arr) {
return Promise.all(arr)
.then(function success(res){
return res;
})
.catch(function error(err) {
throw err;
});
}
module.exports = promiseAll;
```
```js
'use strict';
const promiseAll = require('./exercicio_aula_7_2');
const readDirectory = require('./exercicio_aula_7_2_2');
promiseAll([
readDirectory('./folder1')
])
.then( res => console.log(res))
.catch(err => console.error(err));
```
## Os schemas do mongoose podem usar promises, em seus alguns methods, de “crud”, list 3 methods que usam promise , se chamada da função exec(), no final e 3 que usam exec(), mostre ao menos um exemplo de cada.
### Find
```js
'use strict';
require('./config.js');
const mongoose = require('mongoose');
const Schema = mongoose.Schema;
const _schema = {
name: String,
description: String,
type: String,
attack: Number,
defense: Number,
height: Number,
created_at: { type: Date, default: Date.now }
}
const pokemonSchema = new Schema(_schema);
const PokemonModel = mongoose.model('Pokemon', pokemonSchema);
let promise = PokemonModel.find({}).exec();
promise.then(success, err);
function success(data){
console.log("Success! Msg: "+data);
}
function err(err){
console.log("Error! Msg: "+err);
}
```
### Save
```js
'use strict';
require('./config.js');
const mongoose = require('mongoose');
const Schema = mongoose.Schema;
const _schema = {
name: String,
description: String,
type: String,
attack: Number,
defense: Number,
height: Number,
created_at: { type: Date, default: Date.now }
}
const data = {name: 'Matheusmon'};
const pokemonSchema = new Schema(_schema);
var Model = mongoose.model('pokemons', pokemonSchema);
var poke = new Model(data);
let promise = poke.save();
promise.then(success, err);
function success(data){
console.log("Success! Msg: "+data);
}
function err(err){
console.log("Error! Msg: "+err);
}
```
### Remove
```js
'use strict';
require('./config.js');
const mongoose = require('mongoose');
const Schema = mongoose.Schema;
const _schema = {
name: String,
description: String,
type: String,
attack: Number,
defense: Number,
height: Number,
created_at: { type: Date, default: Date.now }
}
const pokemonSchema = new Schema(_schema);
const PokemonModel = mongoose.model('Pokemon', pokemonSchema);
let promise = PokemonModel.remove({
name: 'Matheusmon'
}).exec();
promise.then(success, err);
function success(data){
console.log("Success! Msg: "+data);
}
function err(err){
console.log("Error! Msg: "+err);
}
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 07 - Exercício
**user:** https://github.com/paulosilva92
**autor:** Paulo Roberto da Silva
**date:** Mon Mar 14 2016 02:12:56 GMT-0300 (BRT)
## Crie um função que entenda de EventEmitter, nela crie um method, um chamado init, ele devera ser chamado toda vez que a sua função foi iniciada. Use o código 04 Como base.(use ele no prototype).
```js
const EventEmitter = require('events').EventEmitter;
const util = require('util');
function Pokemon(data){
this.data = data;
this.on('init:pokemon', avisaInit);
this.on('error',avisaError);
EventEmitter.call(this);
};
Pokemon.prototype.init = function(){
if (this.data.name) {
this.emit('init:pokemon');
} else {
this.emit('error');
};
};
function avisaInit(){
console.log('init ativado');
};
function avisaError(){
console.log('deu erro');
};
util.inherits(Pokemon,EventEmitter);
const data = {name : 'Pikachu'};
const poke = new Pokemon(data);
poke.init();
```
## Faça, um modulo simples para ler diretórios usando modulo FS(fs.readdir), usando o exemplo do código 03, esse modulo deve retornar uma Promise.
```js
'use strict';
const fs = require( 'fs' );
function readFiles(path){
return new Promise(function(resolve, reject){
fs.readdir( path, (err, data) => {
err ? reject( err ) : resolve( data );
});
});
}
function promiseAll(arr){
return Promise.all(arr).then( function success(res){
return res;
})
.catch(function error(err){
throw err;
});
};
promiseAll([
readFiles( './' ),
readFiles( '../' ),
])
.then( res => console.log(res))
.catch(err => console.error(err));
```
## Os schemas do mongoose podem usar promises, em seus alguns methods, de “crud”, list 3 methods que usam promise , se chamada da função exec(), no final e 3 que usam exec(), mostre ao menos um exemplo de cada.
#### find()
```js
var promise = Pokemon.find({}).where({ speed : {$gte : 300}}).exec();
promise.then(success, error);
function success(data){
console.log(data );
}
function error(err){
console.error(err );
}
```
#### delete()
```js
var promise = Pokemon.remove({
_id: '56e4edea660f144f23c1ad6c'
}).exec();
promise.then(success, error);
function success(data){
console.log(, data );
}
function error(err){
console.error(err );
}
```
#### delete()
```js
let promise = Pokemon.remove({_id :’ '5666ff2a9fa2a10c25d57ef7'’})
promise.then(success , error);
function success(data){
console.log(, data );
}
function error(err){
console.error(err );
}
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 11 - Exercício
**user:** [tuchedsf](https://github.com/tuchedsf)
**autor:** Diego Ferreira
**data:** 1467762639020
##Parte 01
### 1- Usando o exemplo do req.params, recebe os parâmetros name, email, cpf, transforme-os em um schema do mongoose, salve-o no mongo e devolva o resultado, usando res.json(user). Use o postman ou o navegador (grave 5 users ou mais):
obs.: os arquivos db-config.js e model.js, não coloquei aqui pois são os arquivo padrões utilizados nas outras aulas do be-mean.
schema.js
```js
'use strict';
const mongoose = require('mongoose');
const nome = {type: String, required: true};
const email = {type: String, required: true};
const cpf = {type: String, required: true};
const _schema = {
nome,
email,
cpf
}
const UserSchema = new mongoose.Schema(_schema);
module.exports = UserSchema;
```
user-model.js
```js
'use strict'
require("./db-config");
const UserSchema = require('./schema');
const UserModel = require('./model')("Usuarios",UserSchema);
const callback = (err, data, res) => {
if (err) res.status(400).send(err);
res.json(data);
};
const CRUD = {
create : (res, user) => {
UserModel.create(user, (err, data) => callback(err, data, res));
}
}
module.exports = CRUD;
```
exercicio1.js
```js
'use strict'
const express = require('express');
const app = express();
const UserModel = require('./user-model');
app.get('/user/nome/:nome/email/:email/cpf/:cpf', (req, res) => {
const nome = req.params.nome;
const email = req.params.email;
const cpf = req.params.cpf;
const user = {"nome": nome, "email":email, "cpf":cpf };
UserModel.create(res, user);
});
app.listen(3000, () => {
console.log("Servidor sendo executado na porta 3000");
});
```
Resultado:
```
Chamadas pelo postman utilizando o método get:
Chamada1: http://localhost:3000/user/nome/Diego/email/tuchedsf@gmail.com/cpf/23434675896
Retorno:
{
"__v": 0,
"nome": "Diego",
"email": "tuchedsf@gmail.com",
"cpf": "23434675896",
"_id": "5786c56b9e7249bb11b3753f"
}
Chamada2: http://localhost:3000/user/nome/teste/email/teste@teste.com/cpf/12345678910
Retorno:
{
"__v": 0,
"nome": "teste",
"email": "teste@teste.com",
"cpf": "12345678910",
"_id": "5786c6369e7249bb11b37540"
}
Chamada3: http://localhost:3000/user/nome/bemean/email/be-mean@be-mean.com/cpf/88888888888
Retorno:
{
"__v": 0,
"nome": "bemean",
"email": "be-mean@be-mean.com",
"cpf": "88888888888",
"_id": "5786c66e9e7249bb11b37541"
}
Chamada4: http://localhost:3000/user/nome/webschool/email/webschool@io.com/cpf/99999999999
Retorno:
{
"__v": 0,
"nome": "webschool",
"email": "webschool@io.com",
"cpf": "99999999999",
"_id": "575c2a8a74d3a2912a7ab07a"
}
Chamada5: localhost:3000/user/nome/tuche/email/tuche@tartaruga.com/cpf/23456787647
Retorno:
{
"__v": 0,
"nome": "tuche",
"email": "tuche@tartaruga.com",
"cpf": "23456787647",
"_id": "575c2ac374d3a2912a7ab07b"
}
```
### 2- Substitua o arquivo, array-query.json, pela collection criada no exercício anterior e repita a busca porém utilizando o schema do mongoose:
user-model.js -> implementado método retrive
```js
'use strict'
require("./db-config");
const UserSchema = require('./schema');
const UserModel = require('./model')("Usuarios",UserSchema);
const callback = (err, data, res) => {
if (err) res.status(400).send(err);
res.json(data);
};
const CRUD = {
create : (res, user) => {
UserModel.create(user, (err, data) => callback(err, data, res));
}
, retrive : (res, query) => {
UserModel.find(query, (err,data) => callback(err,data, res));
}
}
module.exports = CRUD;
```
exercicio2.js
```js
'use strict'
const express = require('express');
const app = express();
const util = require('util');
const UserModel = require('./user-model');
app.get('/find', (req,res) =>{
const q = req.query.q;
console.log(q);
const query = {nome: q};
UserModel.retrive(res, query);
});
app.listen(3000, () => {
console.log('Servidor rodando na porta 3000');
});
```
Resultado:
```
Chamada: localhost:3000/find?q=diego
Retorno:
[
{
"_id": "575c280974d3a2912a7ab077",
"nome": "diego",
"email": "tuchedsf@gmail.com",
"cpf": "11111111111",
"__v": 0
}
]
Chamada: localhost:3000/find?q=teste
Retorno:
[
{
"_id": "575c28eb74d3a2912a7ab078",
"nome": "teste",
"email": "teste@teste.com",
"cpf": "12345678910",
"__v": 0
}
]
```
### 3- Repita o exercício anterior utilizando xml e json na resposta:
Obs.: Não descobri o porque mais passando o json para a função xml, no formato que é retornado do banco a função não consegue fazer o parser e responde <?__/>.
Retorno banco:
[ { cpf: '11111111111',
email: 'tuchedsf@gmail.com',
nome: 'diego' } ]
Quando submeto o retorno acima a funcao let xmlUser = xml(data); o retorno é <?__/>.
Para não dar erro tive que pegar o retorno e colocar cada atributo separado entre {} e ai o parser foi aceito.
{user: [{nome: data[0].nome},{email: data[0].email},{cpf: data[0].cpf}]}
user-model.js -> alterado para atender a funcionalidae
```js
'use strict'
require("./db-config");
const UserSchema = require('./schema');
const UserModel = require('./model')("Usuarios",UserSchema);
const xml = require('xml');
const callback = (err, data, res, type) => {
if (err) res.status(400).send(err);
if (/text\/xml/i.test(type)){
console.log(data);
let xmlUsers = xml({user: [{nome: data[0].nome},{email: data[0].email},{cpf: data[0].cpf} ]});
console.log(xmlUsers);
res.set('Content-Type', 'application/xml');
res.send(xmlUsers);
}else {
res.json(data);
}
};
const CRUD = {
create : (res, user) => {
UserModel.create(user, (err, data) => callback(err, data, res));
}
, retrive : (res, query, type) => {
UserModel.find(query, (err,data) => callback(err,data, res, type));
}
}
module.exports = CRUD;
```
exercicio3.js
```js
'use strict'
const express = require('express');
const app = express();
const util = require('util');
const UserModel = require('./user-model');
app.get('/find', (req,res) =>{
const q = req.query.q;
const query = {nome: q};
const type = req.get('Content-Type');
UserModel.retrive(res, query, type);
});
app.listen(3000, () => {
console.log('Servidor rodando na porta 3000');
});
```
Resultado:
```
//XML
Chamada: localhost:3000/find?q=diego
Parametro cabeçalho: Content-Type = text/xml
Retorno:
<user>
<nome>diego</nome>
<email>tuchedsf@gmail.com</email>
<cpf>11111111111</cpf>
</user>
//JSON
Chamada: localhost:3000/find?q=diego
Parametro cabeçalho: Content-Type = application/json
Retorno:
[
{
"_id": "575c280974d3a2912a7ab077",
"nome": "diego",
"email": "tuchedsf@gmail.com",
"cpf": "11111111111",
"__v": 0
}
]
```
### 4- Usando o formulário no index.html de exemplo use o body-parser como middleware para gravar registros no mongo:
index-body.html
```html
<!DOCTYPE html>
<html>
<head>
<title>Usuários</title>
</head>
<body>
<form action="/user" method="post">
<label>Name: </label>
<input type="text" name="nome" value="" id="nome">
<br/>
<br/>
<label>Email: </label>
<input type="text" name="email" value="" id="email">
<br/>
<br/>
<label>CPF: </label>
<input type="text" name="cpf" value="" id="cpf">
<br/>
<br/>
<button type="submit">Enviar</button>
</form>
</body>
</html>
```
exercicio4.js
```js
'use strict'
const express = require('express');
const app = express();
const fs = require('fs');
const bodyParser = require('body-parser');
const UserModel = require('./user-model');
app.use(bodyParser.json()); // transformar em json
app.use(bodyParser.urlencoded({extended : true})); // para entender urls codificadas para o request ser entendido.
app.post('/user', (req,res) =>{
UserModel.create(res,req.body);
});
app.get('/', (req,res) =>{
res.set('Content-type', 'text/html');
fs.createReadStream('./index-body.html').pipe(res);
});
app.listen(3000, () => {
console.log('Servidor rodando na porta 3000');
});
```
Resultado:
```
Foi passado como parametro no formulario:
Nome: Mulambo
Email: mulambo@mulambinho.com
cpf: 33333333333
Retorno:
{"__v":0,"nome":"mulambo","email":"mulambo@mulambinho.com","cpf":"3333333333","_id":"575c591bbc8a0fa42e750064"}
```
### 5- Usando o index-file.html de exemplo, que usa o formidable, modifique-o de forma que o caminho da imagem que foi gravada no disco, seja gravado no mongodb, na colection users:
schema.js -> adicionado o atributo imagem
```js
'use strict';
const mongoose = require('mongoose');
const nome = {type: String, required: true};
const email = {type: String, required: true};
const cpf = {type: String, required: true};
const imagem = {type: String, required: true};
const _schema = {
nome,
email,
cpf,
imagem
}
const UserSchema = new mongoose.Schema(_schema);
module.exports = UserSchema;
```
index-file.html
```html
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width">
<title>index-file</title>
</head>
<body>
<form action="/upload" method="POST" enctype="multipart/form-data">
<label>Name: </label>
<input type="text" name="nome" value="" id="nome">
<br/>
<br/>
<label>Email: </label>
<input type="text" name="email" value="" id="email">
<br/>
<br/>
<label>CPF: </label>
<input type="text" name="cpf" value="" id="cpf">
<br/>
<br/>
<label>Imagem: </label>
<input type="file" name="image" value="" id="image">
<br/>
<br/>
<button type="submit">Enviar</button>
</form>
</body>
</html>
```
exercicio5.js
```js
'use strict'
const express = require('express');
const app = express();
const fs = require('fs');
const bodyParser = require('body-parser');
const formidable = require('formidable');
const UserModel = require('./user-model');
app.use(bodyParser.json()); // transformar em json
app.use(bodyParser.urlencoded({extended: true})); // para entender urls codificadas para o request ser entendido.
app.post('/upload', (req, res) => {
const form = new formidable.IncomingForm();
form.uploadDir = './public/images';
form.parse(req, (err, fields, files) => {
/*
o formidable possui uma variavel chamada fields, que traz todos os field do formuário que será utilizada para pegar os campos nome, email e cpf
E possui também um variável chamada files, que traz as informações de todos os arquivos enviados pelo formulário. no caso iremos pegar o atributo path para salvar no banco o caminho da imagem que foi salva.
*/
const user = {nome: fields.nome, email: fields.email, cpf: fields.cpf, imagem: files.image.path};
//console.log(user);
UserModel.create(res,user);
});
});
app.get('/', (req, res) => {
res.set('Content-type', 'text/html');
fs.createReadStream('./index-file.html').pipe(res);
});
app.listen(3000, () => {
console.log('Servidor rodando na porta 3000');
});
```
Resultado:
```
Foi passado como parametro no formulario:
Nome: diego
Email: diego@diego.com
cpf: 44444444
imgem: IMG_4548.PNG (selecioada no diretório para upload pelo formulário)
Retorno:
{"__v":0,"nome":"diego","email":"diego@diego.com","cpf":"44444444","imagem":"public/images/upload_8b0e77fbe06d9006a87a663baee165e2","_id":"575d5ad3160bc6fd30d9a919"}
```
##Parte 02
Obs.: Para os exercícios abaixo foram utilizados o schema e o model da Parte 1.
### 1 - Criar as 4 rotas para o CRUD
```js
'use strict'
require ('./db-config');
const express = require('express');
const app = express();
const router = express.Router(); //cria objeto router para redirecionar as requisiçoes para o destino correto.
const UserModel = require('./user-model');
const querystring = require('querystring');
/*
No all nunca utilize funcoes de retorno de algum dado ou modifiquem o formulário.
*/
router.all('*',(req,res,next) => { // router.all é executado para todos os verbos http.
res.setHeader('Webschool', 'FODA');
console.log('all');
next();
});
router.post('/new', (req, res) => {
var body = [];
req.on('data', function(chunk) {
body.push(chunk);
}).on('end', function() {
body = Buffer.concat(body).toString();
const obj = querystring.parse(body);
UserModel.create(res, obj);
});
});
router.get('/find', (req,res) =>{
const q = req.query.q;
//console.log(q);
const query = {nome: q};
const type = req.get('Content-Type');
UserModel.retrive(res, query, type);
});
router.put('/:id', (req,res) => {
const id = req.params.id;
var body = [];
req.on('data', function(chunk) {
body.push(chunk);
}).on('end', function() {
body = Buffer.concat(body).toString();
const obj = querystring.parse(body);
UserModel.update(res,{"_id": id}, obj);
});
});
router.delete('/:id', (req,res) => {
const id = req.params.id;
UserModel.remove(res,{"_id": id});
});
app.use('/users', router);
app.listen(3000,() => {
console.log('Servidor executando na porta 3000.');
});
```
Resultado:
```
Create:
Method: POST
Chamada: localhost:3000/users/new
Parametros x-www-form-urlencoded:
nome: Tartaruga
email: tartaruga@tuche.com
cpf: 23485767348
Resultado:
{
"__v": 0,
"nome": "Tartaruga",
"email": "tartaruga@tuche.com",
"cpf": "23485767348",
"_id": "57688e5a9ea77c550bc7c988"
}
Find:
Method: GET
Chamada: localhost:3000/find?q=diego
Parametro cabeçalho: Content-Type = json
Retorno:
[
{
"_id": "575c280974d3a2912a7ab077",
"nome": "diego",
"email": "tuchedsf@gmail.com",
"cpf": "11111111111",
"__v": 0
},
{
"_id": "575d5ad3160bc6fd30d9a919",
"nome": "diego",
"email": "diego@diego.com",
"cpf": "44444444",
"__v": 0
}
]
Update:
Method: PUT
Chamada: localhost:3000/users/57688e5a9ea77c550bc7c988
Parametros x-www-form-urlencoded:
nome: michelangelo
Retorno:
{
"ok": 1,
"nModified": 1,
"n": 1
}
Delete:
Method: DELETE
Chamada: localhost:3000/users/57688e5a9ea77c550bc7c988
Parametros: n/a
Retorno:
{
"ok": 1,
"n": 1
}
```
### 2 - Criar a arquitetura atomica do Mongoose (Organismo/Ações/Molécula/Átomos/Quarks).
Organização Diretório
- arquit-atomica
+ app.js
+ config
* db-config.js
+ modules
* books
- actions
+ action-create.js
+ action-find.js
+ action-findOne.js
+ action-remove.js
+ action-update.js
+ callback
- atoms
+ atom-autores.js
+ atom-created_at.js
+ atom-dt_publicacao.js
+ atom-generos.js
+ atom-isbn.js
+ atom-qtde_paginas.js
+ atom-resumo.js
+ atom-subtitulo.js
+ atom-titulo.js
- molecules
+ molecule.js
- organisms
+ organism.js
- quarks
+ quark-isISBN-13.js
+ quark-isNumber.js
+ quark-isNumberLengthEQ13isISBN.js
+ quark-toUpperCase.js
+ quark-validate-GT0.js
+ quark-validate-ISBN-13.js
+ quark-validate-str-lengthEQ13.js
+ quark-validate-str-lengthGTE2.js
* model.js
app.js
```js
'use strict';
require ('./config/db-config');
const http = require('http');
const Book = require('./modules/books/organisms/Organism');
const url = require('url');
const queryString = require('queryString');
const books = [{
titulo : "Volta ao Mundo em 80 dias"
, subtitulo : ""
, isbn : 9788525423498
, autores : ['Julio Verne']
, generos : ['acao', 'aventura']
, qtde_paginas: 256
, resumo: "A volta ao mundo em 80 dias (1864) e a sua novela mais celebre, onde narra as peripecias de Phileas Fogg, seu personagem mais famoso, e sua exotica aposta, onde se compromete a fazer a volta ao mundo em oitenta dias"
, dt_publicacao: new Date("October 12, 1990 11:13:00")
},
{
titulo : "Firenheit 141"
, subtitulo : ""
, isbn : 9788573515473
, autores : ['Teste', 'Diego']
, generos : ['acao', 'distopia']
, qtde_paginas: 300
, resumo: "A vida do bombeiro montag nao e mais a mesma desde"
, dt_publicacao: new Date("October 12, 1990 11:13:00")
},{
titulo : "O menino maluquinho"
, subtitulo : ""
, isbn : 9780385351034
, autores : ['Ziraldo']
, generos : ['aventura']
, qtde_paginas: 40
, resumo: "de panelas na cabeca"
, dt_publicacao: new Date("October 12, 1990 11:13:00")
}];
http.createServer ((req,res) => {
const url_parts = url.parse(req.url);
console.log(url_parts);
console.log(url_parts.path);
switch (url_parts.path) {
case '/create':
Book.create(res, books);
break;
case '/find':
const page = 1;
const query1 = { qtde_paginas: {$lte : 256}};
//const query1 = {};
Book.find(res, query1, page);
break;
case '/findOne':
Book.findOne(res, {"_id": "577aecc76013bf6f03e7dee7"});
break;
case '/update':
const queryUpd = {titulo : "Firenheit 141"};
const mod = {subtitulo: "o bombeiro montag e as casas de fogo"};
const multi = false;
Book.update(res, queryUpd, mod, multi);
break;
case '/delete':
const queryRemove = {"_id": "577aecc76013bf6f03e7dee7"};
Book.remove(res, queryRemove);
break;
default:
res.writeHead(404);
res.end("Caminho invalido");
break;
}
}).listen(3000,function(){
console.log("Servidor rodando na porta 3000!!!");
});
```
db-config.js
```js
//importar o mongoose
const mongoose = require('mongoose');
const uriDB = 'mongodb://localhost/mongoose-books-test';
//criar uma conexão com mongo
mongoose.connect(uriDB);
mongoose.connection.on('connected', function(){
console.log("Mongo default connection connected to " + uriDB);
});
mongoose.connection.on('error', function(err){
console.log("Mongo default connection error" + err);
});
mongoose.connection.on('disconnected', function(){
console.log("Mongo default connection disconnected");
});
mongoose.connection.on('open', function(){
console.log("Mongo default connection open");
});
process.on('SIGINT',function(){
mongoose.connection.close(function(){
console.log("The connection is closed");
process.exit(0);
});
});
```
model.js
```js
'use strict';
module.exports = function(ModelName,Schema) {
const mongoose = require('mongoose');
return mongoose.model(ModelName, Schema);
}
```
actions
```js
//action-create.js
'use strict';
const callback = require('./callback');
module.exports = (Model) => {
return (res, book) => {
Model.create(book, (err,data) => callback(err,data,res, 0, 0));
};
};
//action-find.js
'use strict';
const callback = require('./callback');
module.exports = (Model) => {
return (res, query, page) => {
Model.count(query, (err, count) => {
const maxPages = Math.ceil(count/5);
Model.find(query, (err, data) => callback(err,data, res, Number.parseInt(page), Number.parseInt(maxPages))).limit(5).skip(5 * (page - 1));
});
};
}
//action-findOne.js
'use strict';
const callback = require('./callback');
module.exports = (Model) => {
return (res, id) => {
Model.findOne(id, (err,data) => callback(err,data,res, 0, 0));
};
}
//action-remove.js
'use strict';
const callback = require('./callback');
module.exports = (Model) => {
return (res, query) => {
Model.remove(query, (err,data) => callback(err,data,res,0,0));
};
}
//action-update.js
'use strict';
const callback = require('./callback');
module.exports = (Model) => {
return (res,query,mod, opt) => {
const options = opt ? {multi: true} : '';
Model.update(query,mod,options, (err,data) => callback(err,data,res,0,0));
};
}
//callback.js
'use strict';
module.exports = (err,data,res,page,maxPages) => {
if (err) {
res.writeHead(404);
res.end(err.toString());
}
res.writeHead(200, {'Content-Type': 'application/json'});
return res.end(JSON.stringify(data));
};
```
atoms
```js
//atom-autores.js
'use strict'
module.exports = {type: [String], required: true}
//atom-created_at.js
'use strict'
module.exports = { type: Date, default: Date.now }
//atom-dt_publicacao.js
'use strict'
module.exports = { type: Date }
//atom-generos.js
'use strict'
module.exports = {type: [String]}
//atom-isbn.js
'use strict';
module.exports = {
type: Number
, validate: require('../quarks/quark-validate-ISBN-13')
, unique: true
}
//atom-qtde_paginas.js
'use strict';
module.exports = {
type: Number
, validate: require('../quarks/quark-validate-GT0')
}
//atom-resumo.js
'use strict'
module.exports = {
type: String
}
//atom-subtitulo.js
'use strict'
module.exports = {
type: String
}
//atom-titulo.js
'use strict'
module.exports = {
type: String
, validate: require('../quarks/quark-validate-str-lengthGTE2')
, set: require('./../quarks/quark-toUpperCase')
, index: true
, required: true
}
```
quarks
obs.: O quart validate isbn, foi feito por mim para o exercício da aula 12 e aproveitado neste exercício, a explicação do mesmo esta no exercicio 12.
```js
//quark-isISBN-13.js
'use strict';
module.exports = (value) => {
const arrayValues = value.toString().split("").map(Number);
let digCalculado = 0;
if (arrayValues.length != 13 ) return false;
arrayValues.forEach(function (element,index){
if (index != arrayValues.length -1) {
if(index % 2 === 0){
digCalculado = digCalculado + element;
}else {
digCalculado = digCalculado + (element * 3);
}
}
});
digCalculado = (10 - (digCalculado % 10)) % 10;
if (digCalculado === arrayValues[arrayValues.length -1]) return true;
return false;
};
//quark-isNumber.js
'use strict';
module.exports = (value) => {
if ((!isNaN(value) && isFinite(value))|| typeof value === 'number' || value instanceof Number ) return true;
return false;
}
//quark-isNumberLengthEQ13isISBN.js
'use strict';
module.exports = (value) => {
const isNumber = require('./quark-isNumber')(value);
if(!isNumber) return false;
const isLengthEQ13 = require('./quark-validate-str-lengthEQ13')(value);
if(!isLengthEQ13) return false;
const isISBN = require('./quark-isISBN-13')(value);
if(!isISBN) return false;
return true;
}
//quark-toUpperCase.js
'use strict';
module.exports = (v) => v.toUpperCase();
//quark-validate-GTE0.js
'use strict';
module.exports = {
validator: (v) => v >= 0
, message: 'Quantidade de páginas {VALUE} inválida'
};
//quark-validate-ISBN-13.js
'use strict';
module.exports = {
validator : (value) => {
return require('./quark-isNumberLengthEQ13isIsbn')(value);
}
,message: 'ISBN inválido'
}
//quark-validate-strLengthEQ13.js
'use strict';
module.exports = (v) => {
if (v.toString().length == 13) return true;
return false;
};
//quark-validate-str-lengthGTE2.js
'use strict';
module.exports = {
validator: (v) => v.length >= 2
, message: 'Titulo {VALUE} precisa ser maior que 2 caracteres'
}
```
molecule.js
```js
'use strict';
const mongoose = require('mongoose');
const titulo = require('../atoms/atom-titulo');
const subtitulo = require('../atoms/atom-subtitulo');
const isbn = require('../atoms/atom-isbn');
const autores = require('../atoms/atom-autores');
const generos = require('../atoms/atom-generos');
const qtde_paginas = require('../atoms/atom-qtde_paginas');
const resumo = require('../atoms/atom-resumo');
const dt_publicacao = require('../atoms/atom-dt_publicacao');
const created_at = require('../atoms/atom-created_at');
const _schema = {
titulo
, subtitulo
, isbn
, autores
, generos
, qtde_paginas
, resumo
, dt_publicacao
, created_at
}
const BookSchema = new mongoose.Schema(_schema);
module.exports = BookSchema;
```
organism.js
```js
'use strict';
const BookSchema = require('../molecules/Molecule');
const Book = require('../../../modules/model')('Books',BookSchema);
//actions
const create = require('../actions/action-create')(Book);
const find = require('../actions/action-find')(Book);
const findOne = require('../actions/action-findOne')(Book);
const remove = require('../actions/action-remove')(Book);
const update = require('../actions/action-update')(Book);
const CRUD = {
create
, find
, findOne
, update
, remove
};
module.exports = CRUD;
```
Resultado
```
=== CREATE ===
METHOD: GET
URL: http://localhost:3000/create
RETORNO
headers:
Connection →keep-alive
Content-Type →application/json
Date →Mon, 04 Jul 2016 23:09:59 GMT
Transfer-Encoding →chunked
body:
[
{
"__v": 0,
"titulo": "VOLTA AO MUNDO EM 80 DIAS",
"subtitulo": "",
"isbn": 9788525423498,
"qtde_paginas": 256,
"resumo": "A volta ao mundo em 80 dias (1864) e a sua novela mais celebre, onde narra as peripecias de Phileas Fogg, seu personagem mais famoso, e sua exotica aposta, onde se compromete a fazer a volta ao mundo em oitenta dias",
"dt_publicacao": "1990-10-12T14:13:00.000Z",
"_id": "577aecc76013bf6f03e7dee6",
"created_at": "2016-07-04T23:09:59.002Z",
"generos": [
"acao",
"aventura"
],
"autores": [
"Julio Verne"
]
},
{
"__v": 0,
"titulo": "FIRENHEIT 141",
"subtitulo": "",
"isbn": 9788573515473,
"qtde_paginas": 300,
"resumo": "A vida do bombeiro montag nao e mais a mesma desde",
"dt_publicacao": "1990-10-12T14:13:00.000Z",
"_id": "577aecc76013bf6f03e7dee7",
"created_at": "2016-07-04T23:09:59.018Z",
"generos": [
"acao",
"distopia"
],
"autores": [
"Teste",
"Diego"
]
},
{
"__v": 0,
"titulo": "O MENINO MALUQUINHO",
"subtitulo": "",
"isbn": 9780385351034,
"qtde_paginas": 40,
"resumo": "de panelas na cabeca",
"dt_publicacao": "1990-10-12T14:13:00.000Z",
"_id": "577aecc76013bf6f03e7dee8",
"created_at": "2016-07-04T23:09:59.019Z",
"generos": [
"aventura"
],
"autores": [
"Ziraldo"
]
}
]
=== FIND ===
METHOD: GET
URL: http://localhost:3000/find
RETORNO
headers:
Connection →keep-alive
Content-Type →application/json
Date →Mon, 04 Jul 2016 23:19:01 GMT
Transfer-Encoding →chunked
body:
[
{
"_id": "577aecc76013bf6f03e7dee6",
"titulo": "VOLTA AO MUNDO EM 80 DIAS",
"subtitulo": "",
"isbn": 9788525423498,
"qtde_paginas": 256,
"resumo": "A volta ao mundo em 80 dias (1864) e a sua novela mais celebre, onde narra as peripecias de Phileas Fogg, seu personagem mais famoso, e sua exotica aposta, onde se compromete a fazer a volta ao mundo em oitenta dias",
"dt_publicacao": "1990-10-12T14:13:00.000Z",
"__v": 0,
"created_at": "2016-07-04T23:09:59.002Z",
"generos": [
"acao",
"aventura"
],
"autores": [
"Julio Verne"
]
},
{
"_id": "577aecc76013bf6f03e7dee8",
"titulo": "O MENINO MALUQUINHO",
"subtitulo": "",
"isbn": 9780385351034,
"qtde_paginas": 40,
"resumo": "de panelas na cabeca",
"dt_publicacao": "1990-10-12T14:13:00.000Z",
"__v": 0,
"created_at": "2016-07-04T23:09:59.019Z",
"generos": [
"aventura"
],
"autores": [
"Ziraldo"
]
}
]
=== FINDONE ===
METHOD: GET
URL: http://localhost:3000/findOne
RETORNO
headers:
Connection →keep-alive
Content-Type →application/json
Date →Mon, 04 Jul 2016 23:20:25 GMT
Transfer-Encoding →chunked
body:
{
"_id": "577aecc76013bf6f03e7dee7",
"titulo": "FIRENHEIT 141",
"subtitulo": "",
"isbn": 9788573515473,
"qtde_paginas": 300,
"resumo": "A vida do bombeiro montag nao e mais a mesma desde",
"dt_publicacao": "1990-10-12T14:13:00.000Z",
"__v": 0,
"created_at": "2016-07-04T23:09:59.018Z",
"generos": [
"acao",
"distopia"
],
"autores": [
"Teste",
"Diego"
]
}
=== UPDATE ===
METHOD: GET
URL: http://localhost:3000/update
RETORNO
headers:
Connection →keep-alive
Content-Type →application/json
Date →Mon, 04 Jul 2016 23:22:56 GMT
Transfer-Encoding →chunked
body:
{
"ok": 1,
"nModified": 1,
"n": 1
}
=== DELETE ===
METHOD: GET
URL: http://localhost:3000/delete
RETORNO
headers:
Connection →keep-alive
Content-Type →application/json
Date →Mon, 04 Jul 2016 23:23:31 GMT
Transfer-Encoding →chunked
body:
{
"ok": 1,
"n": 1
}
```
### 3 - Integrar as funções do CRUD do Mongoose com o Express.
#####Obs.:Com todas as funçoes do CRUD funcionando via API
Para este exercício foi utilizado os exercicios anteriores e refatorado a para criaçao da api.
app.js
```js
'use strict'
require ('./config/db-config');
const express = require('express');
const app = express();
const BookAPI = require('./modules/books/routes');
app.use('/api/books', BookAPI);
app.listen(3000,() => {
console.log('Servidor executando na porta 3000.');
});
```
modules/books/routes.js
```js
'use strict'
const express = require('express');
const app = express();
const router = express.Router(); //cria objeto router para redirecionar as requisiçoes para o destino correto.
const BookModel = require('../books/organisms/Organism');
const querystring = require('querystring');
router.all('*',(req,res,next) => { // router.all é executado para todos os verbos http.
console.log('all');
next();
});
router.post('/new', (req, res) => {
var body = [];
req.on('data', function(chunk) {
body.push(chunk);
}).on('end', function() {
body = Buffer.concat(body).toString();
const obj = querystring.parse(body);
obj.dt_publicacao = new Date(obj.dt_publicacao);
BookModel.create(res, obj);
});
});
router.get('/find', (req,res,next) =>{
console.log('find');
const page = 1;
const q = req.query.q;
//console.log(q);
const query = q ? {titulo: q} : {};
console.log(query);
// const type = req.get('Content-Type');
BookModel.find(res, query, page);
});
router.get('/:id', (req,res) =>{
console.log('findOne');
const id = req.params.id;
// console.log(id);
const query = {"_id": id};
BookModel.findOne(res, query);
});
router.put('/:id', (req,res) => {
console.log('put / update');
const multi = false;
const id = req.params.id;
var body = [];
req.on('data', function(chunk) {
body.push(chunk);
}).on('end', function() {
body = Buffer.concat(body).toString();
//console.log(body);
const obj = querystring.parse(body);
//console.log(obj);
BookModel.update(res,{"_id": id}, obj, multi);
});
});
router.delete('/:id', (req,res) => {
const id = req.params.id;
BookModel.remove(res,{"_id": id});
});
module.exports = router;
```
Retorno:
```
==== CREATE ====
METHOD: POST
URL: http://localhost:3000/api/books/new
BODY: x-www-form-urlencoded
key: titulo value: a volta dos que não foram
key: subtitulo value: e depois foram novamente
key: isbn value: 9788535927375
key: autores value: diego
key: generos value: drama
key: qtde_paginas value: 2
key: resumo value: eles disseram que iam e nao foram
key: dt_publicacao value: 2016/01/22
Retorno:
{
"__v": 0,
"titulo": "A VOLTA DOS QUE NAO FORAM",
"subtitulo": "e depois foram novamente",
"isbn": 9788535927375,
"qtde_paginas": 2,
"resumo": "eles disseram que iam e nao foram",
"dt_publicacao": "2016-01-22T02:00:00.000Z",
"_id": "577c44c0f66d927c0703e316",
"created_at": "2016-07-05T23:37:36.649Z",
"generos": [
"drama"
],
"autores": [
"diego"
]
}
==== UPDATE ====
METHOD: PUT
URL: http://localhost:3000/api/books/577aecc76013bf6f03e7dee8
BODY: x-www-form-urlencoded
key: subtitulo value: teste sub
Resposta:
{
"ok": 1,
"nModified": 1,
"n": 1
}
==== FIND ====
METHOD: GET
URL: http://localhost:3000/api/books/find
Resposta:
[
{
"_id": "577aecc76013bf6f03e7dee6",
"titulo": "VOLTA AO MUNDO EM 80 DIAS",
"subtitulo": "",
"isbn": 9788525423498,
"qtde_paginas": 258,
"resumo": "A volta ao mundo em 80 dias (1864) e a sua novela mais celebre, onde narra as peripecias de Phileas Fogg, seu personagem mais famoso, e sua exotica aposta, onde se compromete a fazer a volta ao mundo em oitenta dias",
"dt_publicacao": "1990-10-12T14:13:00.000Z",
"__v": 0,
"created_at": "2016-07-04T23:09:59.002Z",
"generos": [
"acao",
"aventura"
],
"autores": [
"Julio Verne"
]
},
{
"_id": "577aecc76013bf6f03e7dee8",
"titulo": "O MENINO MALUQUINHO",
"subtitulo": "teste sub",
"isbn": 9780385351034,
"qtde_paginas": 40,
"resumo": "de panelas na cabeca",
"dt_publicacao": "1990-10-12T14:13:00.000Z",
"__v": 0,
"created_at": "2016-07-04T23:09:59.019Z",
"generos": [
"aventura"
],
"autores": [
"Ziraldo"
]
}
]
==== FIND ONE ====
METHOD: GET
URL: http://localhost:3000/api/books/577aecc76013bf6f03e7dee8
Resposta:
{
"_id": "577aecc76013bf6f03e7dee8",
"titulo": "O MENINO MALUQUINHO",
"subtitulo": "teste sub",
"isbn": 9780385351034,
"qtde_paginas": 40,
"resumo": "de panelas na cabeca",
"dt_publicacao": "1990-10-12T14:13:00.000Z",
"__v": 0,
"created_at": "2016-07-04T23:09:59.019Z",
"generos": [
"aventura"
],
"autores": [
"Ziraldo"
]
}
==== DELETE ====
METHOD: delete
URL: http://localhost:3000/api/books/577aecc76013bf6f03e7dee6
Resposta:
{
"ok": 1,
"n": 1
}
```
### 4 - Criar um módulo reponsável pelas respostas do sistema
callback.js
```js
'use strict';
module.exports = (err,data,res,page,maxPages) => {
if (err) {
res.writeHead(404);
res.end(err.toString());
}
res.writeHead(200, {'Content-Type': 'application/json'});
return res.end(JSON.stringify(data));
};
```
### 5 - Criar um módulo responsável por tratar erros, primeiro parâmetro do callback das funções do Mongoose.
error.js
```js
'use strict';
module.exports = (err,res) => {
res.writeHead(404);
return res.end(err.toString());
};
```
callback.js (alterado com a chamada do modulo de erro)
```js
'use strict';
const error = require('./error');
module.exports = (err,data,res,page,maxPages) => {
if (err) error(err,res);
res.writeHead(200, {'Content-Type': 'application/json'});
return res.end(JSON.stringify(data));
};
```
##Parte 03 - Express Generator
### Criar um CRUD para User, o qual deve possuir os seguintes campos:
- email : String
- password: String
- createAt : Date
## As rotas UPDATE e DELETE devem ser definidas utilizando a variável ':id', para que suas ações executem diretamente no User desejado.
##Criar uma rota que deverá retornar apenas 1 usuário utilizando o seguinte padrão:
- router.get('/:id')
Abaixo coloquei os principais arquivos e/ou que sofreram alguma alteração os demais foram os padrões gerados pelo express generator.
config/db-config.js
```js
//importar o mongoose
const mongoose = require('mongoose');
const uriDB = 'mongodb://localhost/mongoose-users-test';
//criar uma conexão com mongo
mongoose.connect(uriDB);
mongoose.connection.on('connected', function(){
console.log("Mongo default connection connected to " + uriDB);
});
mongoose.connection.on('error', function(err){
console.log("Mongo default connection error" + err);
});
mongoose.connection.on('disconnected', function(){
console.log("Mongo default connection disconnected");
});
mongoose.connection.on('open', function(){
console.log("Mongo default connection open");
});
process.on('SIGINT',function(){
mongoose.connection.close(function(){
console.log("The connection is closed");
process.exit(0);
});
});
```
Modules/model.js
```js
'use strict';
module.exports = function(ModelName,Schema) {
const mongoose = require('mongoose');
return mongoose.model(ModelName, Schema);
}
```
Modules/Users
- actions
```js
//action-create.js
'use strict';
const callback = require('./callback');
module.exports = (Model) => {
return (res, user) => {
console.log("aqui");
Model.create(user, (err,data) => callback(err,data,res, 0, 0));
};
};
//action-find.js
'use strict';
const callback = require('./callback');
module.exports = (Model) => {
return (res, query, page) => {
Model.count(query, (err, count) => {
const maxPages = Math.ceil(count/5);
Model.find(query, (err, data) => callback(err,data, res, Number.parseInt(page), Number.parseInt(maxPages))).limit(5).skip(5 * (page - 1));
});
};
}
//action-findOne.js
'use strict';
const callback = require('./callback');
module.exports = (Model) => {
return (res, id) => {
Model.findOne(id, (err,data) => callback(err,data,res, 0, 0));
};
}
//action-remove.js
'use strict';
const callback = require('./callback');
module.exports = (Model) => {
return (res, query) => {
Model.remove(query, (err,data) => callback(err,data,res,0,0));
};
}
//action-update.js
'use strict';
const callback = require('./callback');
module.exports = (Model) => {
return (res,query,mod, opt) => {
const options = opt ? {multi: true} : '';
Model.update(query,mod,options, (err,data) => callback(err,data,res,0,0));
};
}
//callback.js
'use strict';
const error = require('./error');
module.exports = (err,data,res,page,maxPages) => {
if (err) error(err,res);
res.writeHead(200, {'Content-Type': 'application/json'});
return res.end(JSON.stringify(data));
};
//error.js
'use strict';
module.exports = (err,res) => {
res.writeHead(404);
return res.end(err.toString());
};
```
- atoms
```js
//atom-created_at.js
'use strict'
module.exports = { type: Date, default: Date.now };
//atom-email.js
'use strict'
module.exports = {
type: String
, validate: require('../quarks/quark-isEmail')
, set: require('./../quarks/quark-toLowerCase')
, index: true
, required: true
}
//atom-password.js
'use strict'
module.exports = {type: String
, validate: require('../quarks/quark-validate-str-lengthGTE5')
, required: true
}
```
- molecules
```js
//molecule.js
'use strict';
const mongoose = require('mongoose');
const email = require('../atoms/atom-email');
const password = require('../atoms/atom-password');
const created_at = require('../atoms/atom-created_at');
const _schema = {
email
, password
, created_at
}
const UserSchema = new mongoose.Schema(_schema);
module.exports = UserSchema;
```
- organisms
```js
//Organism.js
'use strict';
const UserSchema = require('../molecules/Molecule');
const User = require('../../../modules/model')('Usuarios',UserSchema);
//actions
const create = require('../actions/action-create')(User);
const find = require('../actions/action-find')(User);
const findOne = require('../actions/action-findOne')(User);
const remove = require('../actions/action-remove')(User);
const update = require('../actions/action-update')(User);
const CRUD = {
create
, find
, findOne
, update
, remove
};
module.exports = CRUD;
```
- quarks
```js
//quark-isEmail.js
'use strict';
module.exports = (value) => {
const regex = /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@([a-z0-9_][-a-z0-9_]*(\.[-a-z0-9_]+)*\.(aero|arpa|biz|com|coop|edu|gov|info|int|mil|museum|name|net|org|pro|travel|mobi|[a-z][a-z])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i;
const isEmpty = require('./quark-isEmpty')(value);
if(isEmpty) return false;
const isString = require('./quark-isString')(value);
if(!isString) return false;
return regex.test(value);
}
//quark-isEmpty.js
'use strict';
module.exports = (value) => {
const isNull = (value === null);
const isUndefined = (value === undefined);
const isEmpty = (value === '');
if (isNull || isUndefined || isEmpty) return true;
return false;
}
//quark-isString.js
'use strict';
module.exports = (value) => {
if (typeof value === 'string' || value instanceof String) return true;
return false;
}
//quark-toLowerCase.js
'use strict';
module.exports = (v) => v.toLowerCase();
//quark-validate-str-lengthGTE5.js
'use strict';
module.exports = {
validator: (v) => v.length >= 5
, message: 'Titulo {VALUE} precisa ser maior que 5 caracteres'
}
```
modules/Users/routes.js
```js
'use strict'
const express = require('express');
const app = express();
const router = express.Router(); //cria objeto router para redirecionar as requisiçoes para o destino correto.
const UserModel = require('../Users/organisms/Organism');
const querystring = require('querystring');
router.all('*',(req,res,next) => { // router.all é executado para todos os verbos http.
console.log('all');
next();
});
router.post('/new', (req, res) => {
console.log("new");
const body = req.body;
console.log(body);
UserModel.create(res, body);
});
router.get('/find', (req,res,next) =>{
console.log('find');
const page = 1;
const q = req.query.q;
const query = q ? {email: q} : {};
console.log(query);
UserModel.find(res, query, page);
});
router.get('/:id', (req,res) =>{
console.log('findOne');
const id = req.params.id;
const query = {"_id": id};
UserModel.findOne(res, query);
});
router.put('/:id', (req,res) => {
console.log('put / update');
const multi = false;
const id = req.params.id;
const body = req.body;
UserModel.update(res,{"_id": id}, body, multi);
});
router.delete('/:id', (req,res) => {
const id = req.params.id;
UserModel.remove(res,{"_id": id});
});
module.exports = router;
```
app.js
```js
'use strict';
require('./config/db-config');
const express = require('express');
const path = require('path');
const favicon = require('serve-favicon');
const logger = require('morgan');
const cookieParser = require('cookie-parser');
const bodyParser = require('body-parser');
const routes = require('./routes/index');
const UsersApi = require('./modules/Users/routes');
var app = express();
// view engine setup
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'jade');
// uncomment after placing your favicon in /public
//app.use(favicon(path.join(__dirname, 'public', 'favicon.ico')));
app.use(logger('dev'));
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: false }));
app.use(cookieParser());
app.use(express.static(path.join(__dirname, 'public')));
app.use('/', routes);
app.use('/api/users', UsersApi);
// catch 404 and forward to error handler
app.use(function(req, res, next) {
var err = new Error('Not Found');
err.status = 404;
next(err);
});
// error handlers
// development error handler
// will print stacktrace
if (app.get('env') === 'development') {
app.use(function(err, req, res, next) {
res.status(err.status || 500);
res.render('error', {
message: err.message,
error: err
});
});
}
// production error handler
// no stacktraces leaked to user
app.use(function(err, req, res, next) {
res.status(err.status || 500);
res.render('error', {
message: err.message,
error: {}
});
});
module.exports = app;
```
package.json
```js
{
"name": "express-generator",
"version": "0.0.0",
"private": true,
"scripts": {
"start": "nodemon ./bin/www"
},
"dependencies": {
"body-parser": "~1.15.1",
"cookie-parser": "~1.4.3",
"debug": "~2.2.0",
"express": "~4.13.4",
"jade": "~1.11.0",
"mongoose": "^4.5.3",
"morgan": "~1.7.0",
"querystring": "^0.2.0",
"serve-favicon": "~2.3.0"
}
}
```
RESULTADO:
```
==== CREATE ====
METHOD: POST
URL: http://localhost:3000/api/users/new
BODY: x-www-form-urlencoded
key: email value: tuchedsf@gmail.com
key: password value: 123456
Retorno:
{
"__v": 0,
"email": "tuchedsf@gmail.com",
"password": "123456",
"_id": "577c584668b8a8fa0a320571",
"created_at": "2016-07-06T01:00:54.712Z"
}
METHOD: POST
URL: http://localhost:3000/api/users/new
BODY: x-www-form-urlencoded
key: email value: teste@gmail.com
key: password value: teste
Retorno:
{
"__v": 0,
"email": "teste@gmail.com",
"password": "teste",
"_id": "577db172c51025080e884979",
"created_at": "2016-07-07T01:33:38.269Z"
}
==== UPDATE ====
METHOD: PUT
URL: http://localhost:3000/api/users/577db172c51025080e884979
BODY: x-www-form-urlencoded
key: password value: naoehmaiteste
{
"ok": 1,
"nModified": 1,
"n": 1
}
==== FIND ====
METHOD: GET
URL: http://localhost:3000/api/users/find
Retorno:
[
{
"_id": "577c584668b8a8fa0a320571",
"email": "tuchedsf@gmail.com",
"password": "123456",
"__v": 0,
"created_at": "2016-07-06T01:00:54.712Z"
},
{
"_id": "577db172c51025080e884979",
"email": "teste@gmail.com",
"password": "naoehmaiteste",
"__v": 0,
"created_at": "2016-07-07T01:33:38.269Z"
}
]
==== FINDONE ====
METHOD: GET
URL: http://localhost:3000/api/users/577c584668b8a8fa0a320571
Retorno:
{
"_id": "577c584668b8a8fa0a320571",
"email": "tuchedsf@gmail.com",
"password": "123456",
"__v": 0,
"created_at": "2016-07-06T01:00:54.712Z"
}
==== DELETE ====
METHOD: delete
URL: http://localhost:3000/api/users/577c584668b8a8fa0a320571
Retorno:
{
"ok": 1,
"n": 1
}
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 11 - Exercício
**User:** [gkal19](https://github.com/gkal19)
**Autor:** Gabriel Kalani
**Data:** 1468455084502
### Índice
##### [Parte 01](#parte-01)
##### [Parte 02](#parte-02)
##### [Parte 03](#parte-03)
### Parte 01
### 1- Usando o exemplo do req.params, recebe os parâmetros name, email, cpf, transforme-os em um schema do mongoose, salve-o no mongo e devolva o resultado, usando res.json(user). Use o postman ou o navegador (grave 5 users ou mais):
```js
// schema.js
'use strict';
const mongoose = require('mongoose');
const nome = {type: String, required: true};
const email = {type: String, required: true};
const cpf = {type: String, required: true};
const _schema = {
nome,
email,
cpf
}
const UserSchema = new mongoose.Schema(_schema);
module.exports = UserSchema;
```
```js
// user-model.js
'use strict'
require("./db-config");
const UserSchema = require('./schema');
const UserModel = require('./model')("Usuarios",UserSchema);
const callback = (err, data, res) => {
if (err) return res.status(400).send(err);
res.json(data);
};
const CRUD = {
create : (res, user) => {
UserModel.create(user, (err, data) => callback(err, data, res));
}
}
module.exports = CRUD;
```
```js
// ex01.js
'use strict'
const express = require('express');
const app = express();
const UserModel = require('./user-model');
app.get('/user/:nome/:email/:cpf', (req, res) => {
const nome = req.params.nome;
const email = req.params.email;
const cpf = req.params.cpf;
const user = {"Nome": nome, "Email":email, "CPF":cpf };
UserModel.create(res, user);
});
app.listen(3000, () => {
console.log("Servidor sendo executado na porta 3000");
});
```
> Com o Postman peguei as chamadas pelo GET
```
// Chamada 1
Chamada1: localhost:3000/user/gabriel/gabrielsilva1956@gmail.com/12345678
Retorno:
{
"__v":0,
"nome":"gabriel",
"email":"gabrielsilva1956@gmail.com",
"cpf":"12345678",
"_id":"57869e24e6475ff30c5fd1ce"
}
// Chamada 2
Chamada2: localhost:3000/user/jean%20suissa/jnascimento@gmail.com/12345678
Retorno:
{
"__v":0,
"nome":"jean suissa",
"email":"jnascimento@gmail.com",
"cpf":"12345678",
"_id":"57869f2de6475ff30c5fd1cf"
}
// Chamada 3
Chamada3: localhost:3000/user/darth%20vader/vader@empire.net/12345678
Retorno:
{
"__v":0,
"nome":"darth vader",
"email":"vader@empire.net",
"cpf":"12345678",
"_id":"57869fb0e6475ff30c5fd1d1"
}
// Chamada 4
Chamada4: localhost:3000/user/chewbacca/chewie@falcon.com/12345678
Retorno:
{
"__v":0,
"nome":"chewbacca",
"email":"chewie@falcon.com",
"cpf":"12345678",
"_id":"57869ff6e6475ff30c5fd1d2"
}
// Chamada 5
Chamada5: localhost:3000/user/han%20solo/han-solo@falcon.com/12345678
Retorno:
{
"__v":0,
"nome":"han solo",
"email":"han-solo@falcon.com",
"cpf":"12345678",
"_id":"5786a04ce6475ff30c5fd1d3"
}
```
### 2- Substitua o arquivo, array-query.json, pela collection criada no exercício anterior e repita a busca porém utilizando o schema do mongoose:
> No arquivo `user-model.js` acrescentei apenas o método para o retrieve.
```js
// user-model.js
'use strict'
require("./db-config");
const UserSchema = require('./schema');
const UserModel = require('./model')("Usuarios",UserSchema);
const callback = (err, data, res) => {
if (err) return res.status(400).send(err);
res.json(data);
};
const CRUD = {
create : (res, user) => {
UserModel.create(user, (err, data) => callback(err, data, res));
}
, retrive : (res, query) => {
UserModel.find(query, (err,data) => callback(err,data, res));
}
}
module.exports = CRUD;
```
```js
// ex02.js
'use strict'
const express = require('express');
const app = express();
const util = require('util');
const UserModel = require('./user-model');
app.get('/find', (req,res) =>{
const q = req.query.q;
console.log(q);
const query = {nome: q};
UserModel.retrive(res, query);
});
app.listen(3000, () => {
console.log('Servidor rodando na porta 3000');
});
```
```
Chamada: localhost:3000/find?q=gabriel
Retorno:
{
"__v":0,
"nome":"gabriel",
"email":"gabrielsilva1956@gmail.com",
"cpf":"12345678",
"_id":"57869e24e6475ff30c5fd1ce"
}
```
### 3- Repita o exercício anterior utilizando xml e json na resposta:
```js
// ex03.js
'use strict'
const express = require('express');
const app = express();
const util = require('util');
const UserModel = require('./user-model');
app.get('/find', (req,res) =>{
const q = req.query.q;
const query = {nome: q};
const type = req.get('Content-Type');
UserModel.retrive(res, query, type);
});
app.listen(3000, () => {
console.log('Servidor rodando na porta 3000');
});
```
```
// XML
Chamada: localhost:3000/find?q=gabriel
Parametro cabeçalho: Content-Type = text/xml
Retorno:
<user>
<nome>Gabriel</nome>
<email>gabrielsilva1956@gmail.com</email>
<cpf>12345678</cpf>
</user>
// JSON
Chamada: localhost:3000/find?q=gabriel
Parametro cabeçalho: Content-Type = application/json
Retorno:
[
{
"_id": "57869e24e6475ff30c5fd1ce",
"nome": "gabriel",
"email": "gabrielsilva1956@gmail.com",
"cpf": "12345678",
"__v": 0
}
]
```
### 4- Usando o formulário no index.html de exemplo use o body-parser como middleware para gravar registros no mongo:
> Sapoarr me lembrou as aulas de Angular1 :smile:
```js
// ex04.js
'use strict'
const express = require('express');
const app = express();
const fs = require('fs');
const bodyParser = require('index');
const UserModel = require('./user-model');
app.use(bodyParser.json()); // transformar em json
app.use(bodyParser.urlencoded({extended : true}));
app.post('/user', (req,res) =>{
UserModel.create(res,req.body);
});
app.get('/', (req,res) =>{
res.set('Content-type', 'text/html');
fs.createReadStream('./index.html').pipe(res);
});
app.listen(3000, () => {
console.log('Servidor rodando na porta 3000');
});
```
```html
<!DOCTYPE html>
<html>
<head>
<title>Usuários</title>
</head>
<body>
<form action="/user" method="post">
<label>Name: </label>
<input type="text" name="nome" value="" id="nome">
<br/>
<br/>
<label>Email: </label>
<input type="text" name="email" value="" id="email">
<br/>
<br/>
<label>CPF: </label>
<input type="text" name="cpf" value="" id="cpf">
<br/>
<br/>
<button type="submit">Enviar</button>
</form>
</body>
</html>
```
> Criei um `user` com os seguintes dados no formulário do arquivo `.html`:
```json
Retorno:
{
"__v":0,
"nome":"teste",
"email":"seu@email.com",
"cpf":"12345678",
"_id":"5786a5b62d7fc6fa8d4cdb30"
}
```
### 5- Usando o index-file.html de exemplo, que usa o formidable, modifique-o de forma que o caminho da imagem que foi gravada no disco, seja gravado no mongodb, na colection users:
> No meu `schema.js` adicionei o atributo `imagem` e criei o arquivo `index-file.html` como pedido:
```html
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width">
<title>Index</title>
</head>
<body>
<form action="/upload" method="POST" enctype="multipart/form-data">
<label>Nome: </label>
<input type="text" name="nome" value="" id="nome">
<br/>
<br/>
<label>Email: </label>
<input type="text" name="email" value="" id="email">
<br/>
<br/>
<label>CPF: </label>
<input type="text" name="cpf" value="" id="cpf">
<br/>
<br/>
<label>Imagem: </label>
<input type="file" name="image" value="" id="image">
<br/>
<br/>
<button type="submit">Enviar</button>
</form>
</body>
</html>
```
> O `formidable` possui uma variável que se chama `fields` que eu vou utilizar para pegar os campos nome, email e cpf. Assim como o `fields` existe o `files` que traz as informações de todos os arquivos enviados pelo formulário.
```js
// ex05.js
'use strict'
const express = require('express');
const app = express();
const fs = require('fs');
const bodyParser = require('body-parser');
const formidable = require('formidable');
const UserModel = require('./user-model');
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({extended: true}));
app.post('/upload', (req, res) => {
const form = new formidable.IncomingForm();
form.uploadDir = './public/images';
form.parse(req, (err, fields, files) => {
const user = {nome: fields.nome, email: fields.email, cpf: fields.cpf, imagem: files.image.path};
//console.log(user);
UserModel.create(res,user);
});
});
app.get('/', (req, res) => {
res.set('Content-type', 'text/html');
fs.createReadStream('./index-file.html').pipe(res);
});
app.listen(3000, () => {
console.log("Servidor sendo executado na porta 3000");
});
```
```
Retorno:
{
"__v":0,
"nome":"gabrielzao",
"email":"gabriel@web.com",
"cpf":"12345678",
"imagem":"public/images/upload_8b0e77fbe06d90057869e2",
"_id":"5786975b69165ba2e6120780"
}
```
### Parte 02
### 1 - Criar as 4 rotas para o CRUD
```js
// ex06.js
'use strict'
require ('./db-config');
const express = require('express');
const app = express();
const router = express.Router(); //cria objeto router para redirecionar as requisiçoes para o destino correto.
const UserModel = require('./user-model');
const querystring = require('querystring');
/*
No all nunca utilize funcoes de retorno de algum dado ou modifiquem o formulário.
*/
router.all('*',(req,res,next) => { // router.all é executado para todos os verbos http.
res.setHeader('Webschool', 'FODA');
console.log('all');
next();
});
router.post('/new', (req, res) => {
var body = [];
req.on('data', function(chunk) {
body.push(chunk);
}).on('end', function() {
body = Buffer.concat(body).toString();
const obj = querystring.parse(body);
UserModel.create(res, obj);
});
});
router.get('/find', (req,res) =>{
const q = req.query.q;
//console.log(q);
const query = {nome: q};
const type = req.get('Content-Type');
UserModel.retrive(res, query, type);
});
router.put('/:id', (req,res) => {
const id = req.params.id;
var body = [];
req.on('data', function(chunk) {
body.push(chunk);
}).on('end', function() {
body = Buffer.concat(body).toString();
const obj = querystring.parse(body);
UserModel.update(res,{"_id": id}, obj);
});
});
router.delete('/:id', (req,res) => {
const id = req.params.id;
UserModel.remove(res,{"_id": id});
});
app.use('/users', router);
app.listen(3000,() => {
console.log('Servidor executando na porta 3000.');
});
```
```
// CREATE
Method: POST
Chamada: localhost:3000/users/new
Parametros x-www-form-urlencoded:
nome: Internet Explorer
email: explorer@windows.com
cpf: 12345678
Resultado:
{
"__v": 0,
"nome": "Internet Explorer",
"email": "explorer@windows.com",
"cpf": "12345678",
"_id": "5786b2562d7fc6fa8d4cdb31"
}
// FIND
Method: GET
Chamada: localhost:3000/find?q=gabriel
Parametro cabeçalho: Content-Type = json
Retorno:
{
"__v":0,
"nome":"gabriel",
"email":"gabrielsilva1956@gmail.com",
"cpf":"12345678",
"_id":"57869e24e6475ff30c5fd1ce"
}
// UPDATE
Method: PUT
Chamada: localhost:3000/user/5786a5b62d7fc6fa8d4cdb30
Parametros x-www-form-urlencoded:
nome: teste
Retorno:
{
"ok": 1,
"nModified": 1,
"n": 1
}
// DELETE
Method: DELETE
Chamada: localhost:3000/user/5786b2562d7fc6fa8d4cdb31
Parametros: n/a
Retorno:
{
"ok": 1,
"n": 1
}
```
### 2 - Criar a arquitetura atomica do Mongoose (Organismo/Ações/Molécula/Átomos/Quarks).
> Aqui também não vou passar a "desgraça" dos arquivos, são grandes demais e não dá pra resumir, se resumir minha cabeça explode.
Mas postarei só o resultado que ocorreu como desejado :smile: :heart:
> Bem, abaixo serão mostrados, livros que eu importei de um .json (encontrado na Deep Web rsrs) e importei para a collection `books` e deu no que deu...
```
// CREATE
METHOD: GET
URL: http://localhost:3000/create
Retorno:
[
{
"id" : "978-1933988177",
"cat" : ["book","paperback"],
"name" : "Lucene in Action, Second Edition",
"author" : "Michael McCandless",
"genre_s" : "IT",
"inStock" : true,
"price" : 30.50,
"pages_i" : 475
},
{
"id" : "978-0641723445",
"cat" : ["book","hardcover"],
"name" : "The Lightning Thief",
"author" : "Rick Riordan",
"genre_s" : "fantasy",
"inStock" : true,
"price" : 12.50,
"pages_i" : 384
},
{
"id" : "978-1423103349",
"cat" : ["book","paperback"],
"name" : "The Sea of Monsters",
"author" : "Rick Riordan",
"genre_s" : "fantasy",
"inStock" : true,
"price" : 6.49,
"pages_i" : 304
}
]
// FIND
METHOD: GET
URL: http://localhost:3000/find
Retorno:
[
{
"id" : "978-1857995879",
"cat" : ["book","paperback"],
"name" : "Sophie's World : The Greek Philosophers",
"author" : "Jostein Gaarder",
"genre_s" : "fantasy",
"inStock" : true,
"price" : 3.07,
"pages_i" : 64
}
]
// UPDATE
METHOD: GET
URL: http://localhost:3000/update
Retorno:
{
"ok": 1,
"nModified": 1,
"n": 1
}
// DELETE
METHOD: GET
URL: http://localhost:3000/delete
Retorno:
{
"ok": 1,
"n": 1
}
```
> Acima no `UPDATE` pedi apenas para alterar o preço do livro The Lightning Thief com o ` "id" : "978-0641723445"`
### 3 - Integrar as funções do CRUD do Mongoose com o Express.
```js
// app.js
'use strict'
require ('./config/db-config');
const express = require('express');
const app = express();
const BookAPI = require('./routes-book');
app.use('/api/books', BookAPI);
app.listen(3000,() => {
console.log('Servidor executando na porta 3000.');
});
```
```
// CREATE
METHOD: POST
URL: http://localhost:3000/api/books/new
BODY: x-www-form-urlencoded
key: cat value: ["book","hardcover"]
key: name value: Star Wars: Tarkin
key: author value: James Luceno
key: genre_s value: fantasy
key: inStock value: true
key: price value: 13,00
key: pages_i value: 368
Retorno:
{
"id":"978-8576572619",
"cat":[
"book",
"paperback"
],
"name":"Star Wars: Tarkin",
"author":"James Luceno",
"genre_s":"Fantasy",
"inStock":true,
"price":13.60,
"pages_i":368
}
// UPDATE
METHOD: PUT
URL: http://localhost:3000/api/books/5786d6bd3ccdb6aa7894070a
BODY: x-www-form-urlencoded
key: author value: J. K. Rowling
Retorno:
{
"ok": 1,
"nModified": 1,
"n": 1
}
// FIND
METHOD: GET
URL: http://localhost:3000/api/books/find
Retorno:
{
"_id":ObjectId("5786d3323ccdb6aa78940703"),
"id":"978-0641723445",
"cat":[
"book",
"hardcover"
],
"name":"The Lightning Thief",
"author":"Rick Riordan",
"series_t":"Percy Jackson and the Olympians",
"sequence_i":1,
"genre_s":"fantasy",
"inStock":true,
"price":12.5,
"pages_i":384
}{
"_id":ObjectId("5786d3323ccdb6aa78940704"),
"id":"978-1423103349",
"cat":[
"book",
"paperback"
],
"name":"The Sea of Monsters",
"author":"Rick Riordan",
"series_t":"Percy Jackson and the Olympians",
"sequence_i":2,
"genre_s":"fantasy",
"inStock":true,
"price":6.49,
"pages_i":304
}{
"_id":ObjectId("5786d3323ccdb6aa78940705"),
"id":"978-1857995879",
"cat":[
"book",
"paperback"
],
"name":"Sophie's World : The Greek Philosophers",
"author":"Jostein Gaarder",
"sequence_i":1,
"genre_s":"fantasy",
"inStock":true,
"price":3.07,
"pages_i":64
}{
"_id":ObjectId("5786d3323ccdb6aa78940706"),
"id":"978-1933988177",
"cat":[
"book",
"paperback"
],
"name":"Lucene in Action, Second Edition",
"author":"Michael McCandless",
"sequence_i":1,
"genre_s":"IT",
"inStock":true,
"price":30.5,
"pages_i":475
}{
"_id":ObjectId("5786d6bd3ccdb6aa78940707"),
"id":"978-8576572619",
"cat":[
"book",
"paperback"
],
"name":"Star Wars: Tarkin",
"author":"James Luceno",
"genre_s":"Fantasy",
"inStock":true,
"price":13.6,
"pages_i":368
}{
"_id":ObjectId("5786d6bd3ccdb6aa78940708"),
"id":"978-8576572633",
"cat":[
"book",
"paperback"
],
"name":"Star Wars: Sombras do Império",
"author":"Steve Perry",
"genre_s":"fantasy",
"inStock":true,
"price":16.49,
"pages_i":448
}{
"_id":ObjectId("5786d6bd3ccdb6aa78940709"),
"id":"978-8532511010",
"cat":[
"book",
"paperback"
],
"name":"Harry Potter E A Pedra Filosofal",
"author":"J. K. Rowlng",
"genre_s":"children",
"inStock":true,
"price":3.07,
"pages_i":224
}{
"_id":ObjectId("5786d6bd3ccdb6aa7894070a"),
"id":"978-8532522610",
"cat":[
"book",
"paperback"
],
"name":"Harry Potter E As Relíquias Da Morte",
"author":"J. K. Rowlng",
"genre_s":"children",
"inStock":true,
"price":30.5,
"pages_i":552
}
// FINDONE
METHOD: GET
URL: http://localhost:3000/api/books/5786d6bd3ccdb6aa7894070a
Retorno:
{
"_id":ObjectId("5786d6bd3ccdb6aa7894070a"),
"id":"978-8532522610",
"cat":[
"book",
"paperback"
],
"name":"Harry Potter E As Relíquias Da Morte",
"author":"J. K. Rowlng",
"genre_s":"children",
"inStock":true,
"price":30.5,
"pages_i":552
}
// DELETE
METHOD: DELETE
URL: http://localhost:3000/api/books/5786d6bd3ccdb6aa7894070a
Retorno:
{
"ok": 1,
"n": 1
}
```
### 4 - Criar um módulo reponsável pelas respostas do sistema
> O arquivo abaixo é o meu antigo `callback.js`
```js
'use strict';
module.exports = (err,data,res,page,maxPages) => {
if (err) {
res.writeHead(404);
res.end(err.toString());
}
res.writeHead(200, {'Content-Type': 'application/json'});
return res.end(JSON.stringify(data));
};
```
### 5 - Criar um módulo responsável por tratar erros, primeiro parâmetro do callback das funções do Mongoose.
```js
// error.js
'use strict';
module.exports = (err,res) => {
res.writeHead(404);
return res.end(err.toString());
};
```
> Esse arquivo abaixo também é o meu `callback.js` antigo, porém melhorei ele para a chamada do módulo do erro, com a ajuda do meu amigo stackoverflow rsrs
```js
'use strict';
const error = require('./error');
module.exports = (err,data,res,page,maxPages) => {
if (err) error(err,res);
res.writeHead(200, {'Content-Type': 'application/json'});
return res.end(JSON.stringify(data));
};
```
### Parte 03
Express Generator
### Criar um CRUD para User, o qual deve possuir os seguintes campos:
- email : String
- password: String
- createAt : Date
> Criar uma rota que deverá retornar apenas 1 usuário utilizando o seguinte padrão:
- router.get('/:id')
> Não coloquei os outros arquivos aqui, pois não quero meu markdown grande e difícil de enteder.
```js
// app.js
'use strict';
require('./config/db-config');
const express = require('express');
const path = require('path');
const favicon = require('serve-favicon');
const logger = require('morgan');
const cookieParser = require('cookie-parser');
const bodyParser = require('body-parser');
const routes = require('./routes/index');
const UsersApi = require('./modules/Users/routes');
var app = express();
// view engine setup
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'jade');
// uncomment after placing your favicon in /public
//app.use(favicon(path.join(__dirname, 'public', 'favicon.ico')));
app.use(logger('dev'));
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: false }));
app.use(cookieParser());
app.use(express.static(path.join(__dirname, 'public')));
app.use('/', routes);
app.use('/api/users', UsersApi);
// catch 404 and forward to error handler
app.use(function(req, res, next) {
var err = new Error('Not Found');
err.status = 404;
next(err);
});
// error handlers
// development error handler
// will print stacktrace
if (app.get('env') === 'development') {
app.use(function(err, req, res, next) {
res.status(err.status || 500);
res.render('error', {
message: err.message,
error: err
});
});
}
// production error handler
// no stacktraces leaked to user
app.use(function(err, req, res, next) {
res.status(err.status || 500);
res.render('error', {
message: err.message,
error: {}
});
});
module.exports = app;
```
```
// CREATE
METHOD: POST
URL: http://localhost:3000/api/users/new
BODY: x-www-form-urlencoded
key: nome value: gkal19
key: email value: gabriel@gkal19.com
key: cpf value: 12345678
Retorno:
{
"__v": 0,
"email": "gabriel@gkal19.com",
"cpf": "12345678",
"_id": "5786c12ab567d843ab13238e"
}
// UPDATE
METHOD: PUT
URL: http://localhost:3000/api/users/578697de69165ba2e6120784
BODY: x-www-form-urlencoded
key: cpf value: 87654321
{
"ok": 1,
"nModified": 1,
"n": 1
}
// FIND
METHOD: GET
URL: http://localhost:3000/api/users/find
Retorno:
{
"_id": "5786975b69165ba2e6120780",
"email": "gabrielsilva1956@gmail.com",
"cpf": "12345678",
"__v": 0
}
// FINDONE
METHOD: GET
URL: http://localhost:3000/api/users/5786978869165ba2e6120781
Retorno:
{
"_id": "5786978869165ba2e6120781",
"email": "vader@empire.net",
"cpf": "12345678",
"__v": 0
}
// DELETE
METHOD: delete
URL: http://localhost:3000/api/users/5786b2562d7fc6fa8d4cdb31
Retorno:
{
"ok": 1,
"n": 1
}
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 03 - Exercício
**user:** [sergiokopplin](https://github.com/sergiokopplin)
**autor:** Sérgio Kopplin
## 1. Por que quando requisitamos ao nosso servidor de *Query String*, **com o Chrome**, ele executa 2 requisições, sendo a última "*vazia*"?
No Chrome a segunda requisição foi a de um favicon. O Status Code é 200 mas não existe conteúdo.
## 2. Qual a DIFERENÇA entre o GET e o POST?
- **GET**: Get é enviado via URL e possui um limite. Ela é mais rápida, porém só comporta textos.
- **POST**: Enviada no corpo da requisição http e não possui limites no tamanho do pacote. Encapsulado para envio e pode conter qualquer tipo de dado.
## 3. Crie um Pokemon na nossa API com seu nome, depois modifique seu nome pelo seu User do Github.
**INCLUSÃO**
```BASH
node http-request-post.js
postData name=Sergio%20Kopplin&type=dev
Tamanho do postData 30
STATUS: 201
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"79","etag":"W/\"4f-S/dEhTwVZmMAZDqbvIBPQw\"","date":"Thu, 11 Feb 2016 00:05:56 GMT","via":"1.1 vegur"}
Dados finalizados: {"__v":0,"name":"Sergio Kopplin","type":"dev","_id":"56bbd0647a041e110010a115"}
```
**ALTERAÇÃO**
```BASH
node http-request-put.js
STATUS: 202
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"108","etag":"W/\"6c-mQ0D9TTjH90glRZwHyt4GA\"","date":"Thu, 11 Feb 2016 00:08:03 GMT","via":"1.1 vegur"}
Dados finalizados: {"data":{"ok":1,"nModified":1,"n":1,"lastOp":"6249818581282848769","electionId":"565e25d106dca622271891c4"}}
```
## 4. **Depois faça o DELETE**, criando o script para tal, colocando aqui a resposta.
```JS
'use strict';
const http = require('http');
const querystring = require('querystring');
const postData = querystring.stringify({
name: ''
});
const options = {
host: 'webschool-io.herokuapp.com'
, method: 'DELETE'
, path: '/api/pokemons/56bbd0647a041e110010a115'
, headers: {
'Content-Type': 'application/x-www-form-urlencoded'
, 'Content-Length': postData.length
}
};
function callback(res) {
console.log('STATUS: ' + res.statusCode);
console.log('HEADERS: ' + JSON.stringify(res.headers));
let data = '';
res.setEncoding('utf8');
res.on('data', (chunk) => {
data += chunk;
});
};
const req = http.request(options, callback);
req.on('error', (e) => {
console.log('ERROOOO: ' + e.message);
});
req.write(postData);
req.end();
```
## 5. Escolha uma **API externa** e crie um script para fazer um GET nela **mostrando o resultado com HTML**.
```JS
'use strict';
const http = require('http');
const options = {
host: 'pokeapi.co'
, path: '/api/v2/pokemon/'
};
function callback(res){
console.log('STATUS: ' + res.statusCode);
console.log('HEADERS: ' + JSON.stringify(res.headers));
res.setEncoding('utf8');
let dados = '';
res.on('data', (chunk) => {
dados += chunk;
});
res.on('end', () => {
let js = JSON.parse(dados);
console.log(js[1]);
console.log('<ul>');
for(var i = 0; i < js.length; i++) {
console.log('<li>' + js[i].name + '</li>');
}
console.log('<ul>');
})
}
const req = http.request(options, callback);
req.on('erros', (e) => {
console.log('ERRO: ' + e.message);
});
req.end();
```
*resultado*
```
node http-request.js
STATUS: 200
HEADERS: {"server":"nginx/1.1.19","date":"Thu, 11 Feb 2016 01:15:06 GMT","content-type":"application/json","transfer-encoding":"chunked","connection":"close","vary":"Cookie","x-frame-options":"SAMEORIGIN","allow":"GET, HEAD, OPTIONS"}
{ name: 'ivysaur', url: 'http://pokeapi.co/api/v2/pokemon/2/' }
<ul>
<li>bulbasaur</li>
<li>ivysaur</li>
...
<li>floette-eternal</li>
<li>latias-mega</li>
<li>latios-mega</li>
<ul>
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 03 - Exercício
**user:** [victorvoid](https://github.com/victorvoid)
**autor:** Victor Igor
## 1. Por que quando requisitamos ao nosso servidor de *Query String*, **com o Chrome**, ele executa 2 requisições, sendo a última "*vazia*"?
Porque na segunda requisição, ele solicita o 'favicon.ico' automaticamente.
## 2. Qual a DIFERENÇA entre o GET e o POST?
- **GET**: Get é enviado via URL e possui um limite de 1024 caracteres, e caso seja ultrapassado, corre o risco da página dar erro.
- **POST**: O Post utiliza a URI para enviar as informações ao servidor, e não tem limite de capacidade de envio de informações e por isso acaba sendo melhor que o GET.
## 3. Crie um Pokemon na nossa API com seu nome, depois modifique seu nome pelo seu User do Github.
```js
/* CRIANDO POKEMON COM MEU NOME */
node class-03.js
STATUS: 201
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"78","etag":"W/\"4e-N6xwBCDNRZ6CzrbPXljoNQ\"","date":"Sat, 05 Mar 2016 23:33:43 GMT","via":"1.1 vegur"}
Resultado: {"__v":0,"name":"Victor Igor","type":"aluno","_id":"56db6cd7bdff001100293034"}
/* ALTERANDO MEU POKEMON PELO MEU USE DO GITHUB*/
node class-03-alterandopokemon.js
STATUS: 202
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"108","etag":"W/\"6c-w8IWqnhJfkE31t3yhBV3iQ\"","date":"Sat, 05 Mar 2016 23:37:19 GMT","via":"1.1 vegur"}
Resultado: {"data":{"ok":1,"nModified":1,"n":1,"lastOp":"6258716705548140545","electionId":"565e25d106dca622271891c4"}}
```
## 4. Depois faça o DELETE, criando o script para tal, colocando aqui a resposta.
```js
'use strict'
const http = require('http');
const options = {
host: 'webschool-io.herokuapp.com'
, method: 'DELETE'
, path: '/api/pokemons/56db6f0abdff001100293035'
};
function callback(res){
console.log('STATUS: '+ res.statusCode);
console.log('HEADERS: '+ JSON.stringify(res.headers));
let data = '';
res.on('data', (chunk)=>{
data += chunk;
});
res.on('end', ()=>{
console.log('Resultado: '+data);
});
}
const req = http.request(options, callback);
req.on('error', (e)=>{
console.log('Ocorreu um erro =< '+ e.message);
});
req.end();
/* Resultado: */
node class-03-deletandopokemon.js
STATUS: 204
HEADERS: {"server":"Cowboy","content-length":"0","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","date":"Sat, 05 Mar 2016 23:46:36 GMT","via":"1.1 vegur"}
Resultado:
```
## 5. Escolha uma API externa e crie um script para fazer um GET nela mostrando o resultado com HTML.
```JS
node class-03-getAPI.js
STATUS: 200
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"5517","etag":"W/\"158d-c8PSQN++DR9ObSkS3s0RWA\"","date":"Sun, 06 Mar 2016 00:48:35 GMT","via":"1.1 vegur"}
Resultado: <html><body><div>[{"_id":"568c4f016b71ba1100229ee6","name":"Bilica","type":"professor","__v":0},{"_id":"56954df660679d11000236fe","name":"Bilica","type":"Zica da Balada","__v":0},{"_id":"56983d9d8446e71100c68842","name":"Bilica","type":"Aluno","__v":0},{"_id":"569c402d50a0f01100292c9e","name":"Bilica","type":"Aluno","__v":0},{"_id":"56ad3787200ef511003a086a","name":"Bilica","__v":0},{"_id":"56ae6ede18f5f71100b157c6","name":"Bilica","type":"developer","__v":0},{"_id":"56b09cc25ad7d111001ec9b8","name":"Bilica","type":"professor","__v":0},{"_id":"56b09f485ad7d111001ec9b9","name":"Bilica","type":"professor","__v":0},{"_id":"56b09f6a5ad7d111001ec9bb","name":"Bilica","type":"professor","__v":0},{"_id":"56b0ad877229a31100582ff4","__v":0,"name":"Bilica"},{"_id":"56b0ae837229a31100582ff5","__v":0,"name":"Bilica"},{"_id":"56b0afda7229a31100582ff6","__v":0,"name":"Bilica"},{"_id":"56b0b0be7229a31100582ff7","__v":0,"name":"Bilica"},{"_id":"56b0b12f7229a31100582ff8","__v":0,"name":"Bilica"},{"_id":"56b0b16b7229a31100582ff9","__v":0,"name":"Bilica"},{"_id":"56b0b1d17229a31100582ffa","__v":0,"name":"Bilica"},{"_id":"56b0b2007229a31100582ffb","__v":0,"name":"Bilica"},{"_id":"56b0b5af7229a3110</div><div>0582ffc","__v":0,"name":"Bilica"},{"_id":"56b0b6157229a31100582ffd","__v":0,"name":"Bilica"},{"_id":"56b0b6527229a31100582ffe","__v":0,"name":"Bilica"},{"_id":"56b0b6597229a31100582fff","__v":0,"name":"Bilica"},{"_id":"56b106be64a60411007c3e2b","__v":0,"name":"Bilica"},{"_id":"56b106cc64a60411007c3e2c","__v":0,"name":"Bilica"},{"_id":"56b106dd64a60411007c3e2d","__v":0,"name":"Bilica"},{"_id":"56b1089e64a60411007c3e2e","__v":0,"name":"Bilica"},{"_id":"56b246c5520ef61100b0d75b","name":"Bilica","type":"Analista S.","__v":0},{"_id":"56b32d4d8584471100d6ff1d","__v":0,"name":"Bilica"},{"_id":"56b32d4f8584471100d6ff1e","__v":0,"name":"Bilica"},{"_id":"56b3ea986cb772110086c190","name":"Bilica","type":"professor","__v":0},{"_id":"56b54c365795bb110075fbaf","name":"Bilica","type":"aluno","__v":0},{"_id":"56b6453c4f05f4110063ea08","name":"Bilica","type":"Aluno do Be Mean","__v":0},{"_id":"56b7cf047b9f54110011fa79","name":"Bilica","type":"Aluno","__v":0},{"_id":"56b7d6c97b9f54110011fa7a","name":"Bilica","type":"aluno","__v":0},{"_id":"56b7d7ed7b9f54110011fa7b","name":"Bilica","type":"aluno","__v":0},{"_id":"56b7ff3b510b5d110014a6ed","name":"Bilica","type":"Aluno","__v":0},{"_id":"56b80d35ff45d31100182507","name":"Bilica","type":"aluno","__v":0},{"_id":"56b8a337c636191100dea91c","__v":0,"name":"Bilica"},{"_id":"56b8a79bc636191100dea91e","name":"Bilica","type":"aluno","__v":0},{"_id":"56b8a982c636191100dea91f","name":"Bilica","type":"aluno","__v":0},{"_id":"56b8a9e0c636191100dea921","name":"Bilica","type":"aluno","__v":0},{"_id":"56b8c8eb56b97311007c7ebf","name":"Bilica","type":"professor","__v":0},{"_id":"56b8dcbd7586941100aaf254","name":"Bilica","type":"Professor","__v":0},{"_id":"56b8df8f7586941100aaf255","name":"Bilica","type":"Professor","__v":0},{"_id":"56ba0d6adaf4af110073de78","__v":0,"name":"Bilica"},{"_id":"56bb6c7b81fa011100369fc3","name":"Bilica","type":"Water","height":1.6,"__v":0},{"_id":"56bbbcc182124e110077f53e","name":"Bilica","type":"teacher","__v":0},{"_id":"56bbc22b82124e110077f53f","name":"Bilica","__v":0},{"_id":"56bbc25c82124e110077f540","name":"Bilica","__v":0},{"_id":"56bd1aa22c257311009b5723","name":"Bilica","type":"aluno","__v":0},{"_id":"56c0f66664bae31100ebb879","name":"Bilica","type":"Aluno","__v":0},{"_id":"56c1fca27d062611000a1113","name":"Bilica","type":"aluno","__v":0},{"_id":"56c1fdab7d062611000a1114","name":"Bilica","type":"fire","__v":0},{"_id":"56c333e192ca4e110026e8e8","name":"Bilica","type":"Loko dos Baguio","__v":0},{"_id":"56c466ab1b09dc11002f3b9a","name":"Bilica","type":"voador","__v":0},{"_id":"56c8cda4a0299011005601d3","name":"Bilica","type":"Aluno","__v":0},{"_id":"56c922da8583cb11008176a9","name":"Bilica","type":"professor","__v":0},{"_id":"56cb86c82847fb1100a035e4","__v":0,"name":"Bilica"},{"_id":"56cb88bb2847fb1100a035e5","__v":0,"name":"Bilica"},{"_id":"56cb89352847fb1100a035e6","__v":0,"name":"Bilica"},{"_id":"56cb89492847fb1100a035e7","__v":0,"name":"Bilica"},{"_id":"56cb895b2847fb1100a035e8","__v":0,"name":"Bilica"},{"_id":"56cb895e2847fb1100a035e9","__v":0,"name":"Bilica"},{"_id":"56cc86fcd7b91611009bfe4b","__v":0,"name":"Bilica"},{"_id":"56cc89f5d7b91611009bfe4c","__v":0,"name":"Bilica"},{"_id":"56cc8a30d7b91611009bfe4d","name":"Bilica","type":"Fat","__v":0},{"_id":"56cca9450f4ac811005fb173","name":"Bilica","type":"Fat","__v":0},{"_id":"56cd27e473a6431100ba1de9","name":"Bilica","type":"professor","__v":0},{"_id":"56ce4dca8423d41100c0a9dc","name":"Bilica","type":"professor","__v":0},{"_id":"56ce85ddac1315110043cffa","name":"Bilica","type":"professor","__v":0},{"_id":"56ce865aac1315110043cffb","name":"Bilica","type":"aluno","__v":0},{"_id":"56d1f4e5e7973e11003588ba","name":"Bilica","type":"professor","__v":0},{"_id":"56d1f61ce7973e11003588bb","name":"Bilica","type":"aluno","__v":0},{"_id":"56d3772f835b421100aaed6c","name":"Eduardo Garcia","type":"aluno","__v":0},{"_id":"56d4ae6361ebc311008a82d1","__v":0},{"_id":"56d4b37d61ebc311008a82d2","name":"Jean Nascimento","type":"professor","__v":0},{"_id":"56db63edbdff001100293031","name":"Victor Igor","type":"aluno","__v":0},{"_id":"56d610e1b9f4861100c2cd57","name":"Jack Baura","type":"maconheiro","__v":0},{"_id":"56d75a62654832110058d892","name":"Eduardo Garcia","type":"aluno","__v":0},{"_id":"56db6693bdff001100293033","name":"Guitarra Modificada","type":"stratocaster","__v":0}]</div></body></html>
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 03 - Exercício
**user:** [lesilva00](https://github.com/lesilva00)
**autor:** Luís Eduardo Tenório Silva
**date:** 1456600950642
## Por que quando requisitamos ao nosso servidor de *Query String*, **com o Chrome**, ele executa 2 requisições, sendo a última "*vazia*"?
Em vários navegadores, a segunda requisição é realizada para requisitar o componente _favicon.ico_.
## Qual a DIFERENÇA entre o GET e o POST?
GET e POST são métodos utilizados no protocolo HTTP para realizar uma atividade específica.
O método GET é utilizado quando requisitamos alguma informação do servidor.
O método POST é utilizado quando desejamos inserir no servidor um ou mais dados.
## Crie um Pokemon na nossa API com seu nome, depois modifique seu nome pelo seu User do Github.
### Criando o Pokemon
```js
'use strict';
var querystring = require('querystring');
var http = require('http');
const postData = querystring.stringify({
name:'Luís Eduardo',
type:'Aluno'
});
const options = {
host:'webschool-io.herokuapp.com',
method:'POST',
path:'/api/pokemons',
headers:{
'Content-Type':'application/x-www-form-urlencoded',
'Content-Length':postData.length
}
}
function callback(res){
console.log('STATUS CODE: ' + res.statusCode);
console.log('HEADERS: ' + JSON.stringify(res.headers));
let data = '';
res.setEncoding('utf-8');
res.on('data', chunck => {
data += chunck;
});
res.on('end', () => {
console.log("Dados totais recebidos: " + data);
});
}
var request = http.request(options,callback);
request.on('error', error => {
console.log('Error: ' + error.message);
});
request.write(postData);
request.end();
```
Saída do Node.js
```
$ node http-post-execution.js
STATUS CODE: 201
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"80","etag":"W/\"50-qpBmZ7pdtUhKR33kqXXBzw\"","date":"Tue, 09 Aug 2016 14:10:24 GMT","via":"1.1 vegur"}
Dados totais recebidos: {"__v":0,"name":"Luís Eduardo","type":"Aluno","_id":"57a9e450d3285e1100a0deb8"}
```
###Editando o Pokemon
```js
'use strict';
var querystring = require('querystring');
var http = require('http');
const putData = querystring.stringify({
name:'lesilva00'
});
const options = {
host:'webschool-io.herokuapp.com',
method:'PUT',
path:'/api/pokemons/57a9e450d3285e1100a0deb8',
headers:{
'Content-Type':'application/x-www-form-urlencoded',
'Content-Length':putData.length
}
}
function callback(res){
console.log('STATUS CODE: ' + res.statusCode);
console.log('HEADERS: ' + JSON.stringify(res.headers));
let data = '';
res.setEncoding('utf-8');
res.on('data', chunck => {
data += chunck;
});
res.on('end', () => {
console.log("Dados totais recebidos: " + data);
});
}
var request = http.request(options,callback);
request.on('error', error => {
console.log('Error: ' + error.message);
});
request.write(putData);
request.end();
```
Saída do Node.js
```
$ node http-put-execution.js
STATUS CODE: 202
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"108","etag":"W/\"6c-eWEgyhvz97x3SSsZRX7m0A\"","date":"Tue, 09 Aug 2016 14:17:38 GMT","via":"1.1 vegur"}
Dados totais recebidos: {"data":{"ok":1,"nModified":1,"n":1,"lastOp":"6316832848628154369","electionId":"576451dfece94f32689e021d"}}
```
## **Depois faça o DELETE**, criando o script para tal, colocando aqui a resposta.
```js
'use strict';
var querystring = require('querystring');
var http = require('http');
const options = {
host:'webschool-io.herokuapp.com',
method:'DELETE',
path:'/api/pokemons/57a9e450d3285e1100a0deb8',
headers:{
'Content-Type':'application/x-www-form-urlencoded'
}
}
function callback(res){
console.log('STATUS CODE: ' + res.statusCode);
console.log('HEADERS: ' + JSON.stringify(res.headers));
let data = '';
res.setEncoding('utf-8');
res.on('data', chunck => {
data += chunck;
});
res.on('end', () => {
console.log("Dados totais recebidos: " + data);
});
}
var request = http.request(options,callback);
request.on('error', error => {
console.log('Error: ' + error.message);
});
request.end();
```
Saída do Node.js
```
STATUS CODE: 204
HEADERS: {"server":"Cowboy","content-length":"0","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","date":"Tue, 09 Aug 2016 14:24:08 GMT","via":"1.1 vegur"}
Dados totais recebidos:
```
## Escolha uma **API externa** e crie um script para fazer um GET nela **mostrando o resultado com HTML**.
Utilizei a api do [Star Wars](http://swapi.co/api/people) após observar os exemplos dos meus colegas.
```js
'use strict';
const http = require('http');
const options = {
host:'swapi.co',
path:'/api/people/10',
headers:{
'Content-Type':'text/html'
}
}
function callback(res){
console.log('STATUS CODE: ' + res.statusCode);
console.log('HEADERS: '+ JSON.stringify(res.headers));
let data = '';
res.on('data', chunck => {
data += chunck;
});
res.on('end', () => {
console.log('Dados finais: ' + data);
});
}
http.get(options,callback);
```
Resposta
```js
STATUS CODE: 301
HEADERS: {"date":"Tue, 09 Aug 2016 14:37:48 GMT","content-type":"text/html; charset=utf-8","transfer-encoding":"chunked","connection":"close","set-cookie":["__cfduid=d5018a39ef2846e3f8467399e75dee42e1470753468; expires=Wed, 09-Aug-17 14:37:48 GMT; path=/; domain=.swapi.co; HttpOnly"],"location":"http://swapi.co/api/people/10/","x-frame-options":"SAMEORIGIN","via":"1.1 vegur","server":"cloudflare-nginx","cf-ray":"2cfbf2bb35854a96-GRU"}
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 03 - Exercício
**user:** [maurienefirmino](https://github.com/maurienefirmino)<br>
**autor:** Mauriene Firmino do Nascimento Júnior<br>
**date:** 1476019304746
## Por que quando requisitamos ao nosso servidor de *Query String*, **com o Chrome**, ele executa 2 requisições, sendo a última "*vazia*"?
Por causa do favicon.ico
## Qual a DIFERENÇA entre o GET e o POST?
O GET faz uma requisição e retorna algo, o POST envia algo para a requisição.
## Crie um Pokemon na nossa API com seu nome, depois modifique seu nome pelo seu User do Github.
**Criando um Pokemon**
```
'use strict';
const http = require('http');
const querystring = require('querystring');
const postData = querystring.stringify({
name: 'Mauriene Firmino do Nascimento Júnior'
, type: 'Student'
});
const options = {
host: 'webschool-io.herokuapp.com'
, method: 'POST'
, path: '/api/pokemons'
, headers: {
'Content-Type': 'application/x-www-form-urlencoded'
, 'Content-Length': postData.length
}
};
function callback(res) {
console.log('STATUS: ' + res.statusCode);
console.log('HEADERS: ' + JSON.stringify(res.headers));
let data = '';
res.setEncoding('utf8');
res.on('data', (chunk) => {
data += chunk;
});
res.on('end', () => {
console.log('Dados finalizados: ', data)
})
}
const req = http.request(options, callback);
req.on('error', (e) => {
console.log('Error: ' + e.message);
});
req.write(postData);
req.end();
```
**Resultado do console**
```
mauriene@mauriene-J1800NH:~/node/exercicios$ node aula03.js
STATUS: 201
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"107","etag":"W/\"6b-tGETF/Ww5/WtW30XSYBmQQ\"","date":"Sun, 09 Oct 2016 13:25:41 GMT","via":"1.1 vegur"}
Dados finalizados: {"__v":0,"name":"Mauriene Firmino do Nascimento Júnior","type":"Student","_id":"57fa4555719eff00115a6f39"}
mauriene@mauriene-J1800NH:~/node/exercicios$
```
**Modificando**
```
'use strict';
const http = require('http');
const querystring = require('querystring');
const postData = querystring.stringify({
name: 'Mauriene Firmino Modificado'
});
const options = {
host: 'webschool-io.herokuapp.com'
, method: 'PUT'
, path: '/api/pokemons/57fa4555719eff00115a6f39'
, headers: {
'Content-Type': 'application/x-www-form-urlencoded'
, 'Content-Length': postData.length
}
};
function callback(res) {
console.log('STATUS: ' + res.statusCode);
console.log('HEADERS: ' + JSON.stringify(res.headers));
let data = '';
res.setEncoding('utf8');
res.on('data', (chunk) => {
data += chunk;
});
res.on('end', () => {
console.log('Dados finalizados: ', data)
})
}
const req = http.request(options, callback);
req.on('error', (e) => {
console.log('Error: ' + e.message);
});
req.write(postData);
req.end();
```
**Resultado do Console**
```
mauriene@mauriene-J1800NH:~/node/exercicios$ node aula03-update.js
STATUS: 202
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"121","etag":"W/\"79-zxawyjvjaCchay4+sweRcw\"","date":"Sun, 09 Oct 2016 13:30:28 GMT","via":"1.1 vegur"}
Dados finalizados: {"data":{"ok":1,"nModified":1,"n":1,"opTime":{"ts":"6339456889507545089","t":0},"electionId":"7fffffff0000000000000000"}}
mauriene@mauriene-J1800NH:~/node/exercicios$
```
## **Depois faça o DELETE**, criando o script para tal, colocando aqui a resposta.
```
'use strict';
const http = require('http');
const querystring = require('querystring');
const options = {
host: 'webschool-io.herokuapp.com'
, method: 'DELETE'
, path: '/api/pokemons/57fa4555719eff00115a6f39'
, headers: {
'Content-Type': 'application/x-www-form-urlencoded'
}
};
function callback(res) {
console.log('STATUS: ' + res.statusCode);
console.log('HEADERS: ' + JSON.stringify(res.headers));
let data = '';
res.setEncoding('utf8');
res.on('data', (chunk) => {
data += chunk;
});
res.on('end', () => {
console.log('Dados finalizados: ', data)
})
}
const req = http.request(options, callback);
req.on('error', (e) => {
console.log('Error: ' + e.message);
});
req.end();
```
**Resultado do Console**
```
mauriene@mauriene-J1800NH:~/node/exercicios$ node aula03-delete.js
STATUS: 204
HEADERS: {"server":"Cowboy","content-length":"0","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","date":"Sun, 09 Oct 2016 13:33:22 GMT","via":"1.1 vegur"}
Dados finalizados:
mauriene@mauriene-J1800NH:~/node/exercicios$
```
## Escolha uma **API externa** e crie um script para fazer um GET nela **mostrando o resultado com HTML**.
```
'use strict';
const http = require('http');
const json2html = require('node-json2html');
const options = {
host: 'pokeapi.co'
, path: '/api/v2/pokemon/'
};
function callback(res) {
console.log('STATUS:' + res.statusCode);
console.log('HEADERS:' + JSON.stringify(res.headers));
res.setEncoding('utf8');
let data = '';
res.on('data', (chunk) => {
data += chunk;
});
res.on('end', ()=>{
var transform = {'tag':'div','html':'${name} - url: ${url}'};
var html = json2html.transform(data,transform);
console.log(html);
});
}
const req = http.request(options, callback);
req.on('error', (e) => {
console.log('Error: ' + e.message);
});
req.end();
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 03 - Exercício
**user:** [matheusjkweber](https://github.com/matheusjkweber)<br>
**autor:** Matheus José Krumenauer Weber<br>
**date:** 1456600950642
## Por que quando requisitamos ao nosso servidor de *Query String*, **com o Chrome**, ele executa 2 requisições, sendo a última "*vazia*"?
Ele envia a segunda requisição porque ele está requisitando o favicon.
## Qual a DIFERENÇA entre o GET e o POST?
O GET é utilizado para quando queremos acessar alguma informação no servidor, outra coisa, o mesmo é visualizado através da url(a querystring após o endereço do servidor), e só pode enviar texto.
O POST é utilizado para quando queremos gravar alguma informação no servidor, pode enviar diversos tipos de dados(texto, arquivos, etc...).
## Crie um Pokemon na nossa API com seu nome, depois modifique seu nome pelo seu User do Github.
Criando o Pokemon
```js
STATUS: 201
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"96","etag":"W/\"60-KBGEvOm+tN4IZCOXBi7JbA\"","date":"Sat, 27 Feb 2016 19:25:42 GMT","via":"1.1 vegur"}
Dados finalizados: {"__v":0,"name":"Matheus Jose Krumenauer Weber","type":"aluno","_id":"56d1f836e7973e11003588bc"}
```
Editando o Pokemon
```js
STATUS: 202
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"108","etag":"W/\"6c-Q0c57XIKE+tyOOl5YY+7yA\"","date":"Sat, 27 Feb 2016 19:27:09 GMT","via":"1.1 vegur"}
Dados finalizados: {"data":{"ok":1,"nModified":1,"n":1,"lastOp":"6256054641868406785","electionId":"565e25d106dca622271891c4"}}
```
## **Depois faça o DELETE**, criando o script para tal, colocando aqui a resposta.
```js
STATUS: 204
HEADERS: {"server":"Cowboy","content-length":"0","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","date":"Sat, 27 Feb 2016 19:27:53 GMT","via":"1.1 vegur"}
```
## Escolha uma **API externa** e crie um script para fazer um GET nela **mostrando o resultado com HTML**.
Utilizei a api do pokeapi.co.
```js
'use strict';
const http = require('http');
const json2Html = require('node-json2html')
http.get({
hostname: 'pokeapi.co',
path: '/api/v2/pokemon/137/',
agent: false
}, (response) => {
let body = '';
console.log('STATUS: ' + response.statusCode);
console.log('HEADERS: ' + JSON.stringify(response.headers));
response.on('data', function(data) {
body += data;
});
response.on('end', function() {
var html = json2html.transform(body, {"tag": "div","id": "${id}","html": "${name}"});
console.log(html);
});
});
```
Resposta
```js
STATUS: 200
HEADERS: {"server":"nginx/1.1.19","date":"Sat, 27 Feb 2016 19:36:56 GMT","content-type":"application/json","transfer-encoding":"chunked","connection":"close","vary":"Cookie","x-frame-options":"SAMEORIGIN","allow":"GET, HEAD, OPTIONS"}
<div id="137">porygon</div>
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 03 - Exercício
**user:** [vitorcapretz](https://github.com/vitorcapretz)
**autor:** Vitor Capretz
**date:** 1465911866403
## 1. Por que quando requisitamos ao nosso servidor de Query String, com o Chrome, ele executa 2 requisições, sendo a última "vazia"?
Isso pode ser facilmente entendido apenas abrindo a aba Network no navegador: ao abrir o localhost com a porta onde o Node está sendo executado e com os parâmetros na Querystring, é possível visualizar duas requisições.
Uma delas é efetivamente a requisição passando os parâmetros da Querystring, mas a segunda é uma requisição no path "/favicon.ico", e esta não possui parâmetros na Querystring, resultando em um print vazio no console do Node.
## 2. Qual a diferença entre o `GET` e o `POST`?
* GET - além de passarmos os parâmetros via URL, ele é usado em uma API para as buscas no banco de dados.
* POST - nele os parâmetros são enviados via form (Content-Type: "application/x-www-form-urlencoded") e no desenvolvimento de uma API, é utilizado para inserção de dados.
## 3. Crie um Pokemon na nossa API com seu nome, depois modifique seu nome pelo seu User do Github.
#### Inserção
```js
'use strict';
const http = require('http');
const queryString = require('querystring');
const postData = queryString.stringify({
name: 'Vitor Capretz',
type: 'student'
});
const options = {
host: 'webschool-io.herokuapp.com',
method: 'POST',
path: '/api/pokemons',
headers:{
'Content-Type': 'application/x-www-form-urlencoded',
'Content-Length': postData.length
}
};
let callback = res => {
console.log('status: ' + res.statusCode);
console.log('headers: ', JSON.stringify(res.headers));
let data = '';
res.setEncoding('utf8');
res.on('data', chunk => {
data += chunk;
});
res.on('end', () => {
console.log('data completed: ', data);
});
}
const req = http.request(options, callback);
req.on('error', e => {
console.log('ops, deu esse erro aqui: ', e.message);
});
req.write(postData);
req.end();
```
```
vitor@vitor-ThinkPad-T440:/var/www/html/workshop-be-mean/nodejs/http$ node http-request-post.js
status: 201
headers: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"82","etag":"W/\"52-iFuBRJjN4Q5qLRmix8A8cw\"","date":"Tue, 14 Jun 2016 14:11:58 GMT","via":"1.1 vegur"}
data completed: {"__v":0,"name":"Vitor Capretz","type":"student","_id":"576010aeebf517110060cadb"}
```
#### Alteração
```js
'use strict';
const http = require('http');
const queryString = require('querystring');
const postData = queryString.stringify({
name: 'vitorcapretz'
});
const options = {
host: 'webschool-io.herokuapp.com',
method: 'PUT',
path: '/api/pokemons/576010aeebf517110060cadb',
headers:{
'Content-Type': 'application/x-www-form-urlencoded',
'Content-Length': postData.length
}
};
let callback = res => {
console.log('status: ' + res.statusCode);
console.log('headers: ', JSON.stringify(res.headers));
let data = '';
res.setEncoding('utf8');
res.on('data', chunk => {
data += chunk;
});
res.on('end', () => {
console.log('data completed: ', data);
});
}
const req = http.request(options, callback);
req.on('error', e => {
console.log('ops, deu esse erro aqui: ', e.message);
});
req.write(postData);
req.end();
```
```
vitor@vitor-ThinkPad-T440:/var/www/html/workshop-be-mean/nodejs/http$ node http-request-put.js
status: 202
headers: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"108","etag":"W/\"6c-AiMYwinMu+qHyurLRUAifA\"","date":"Tue, 14 Jun 2016 14:13:49 GMT","via":"1.1 vegur"}
data completed: {"data":{"ok":1,"nModified":1,"n":1,"lastOp":"6296051095315677185","electionId":"56ee12f2563048036a1e77e7"}}
```
## 4. Depois faça o `DELETE`, criando o script para tal, colocando aqui a resposta.
```js
'use strict';
const http = require('http');
const options = {
host: 'webschool-io.herokuapp.com',
method: 'DELETE',
path: '/api/pokemons/575de43cda6e731100bfdad5'
};
let callback = res => {
console.log('status: ' + res.statusCode);
console.log('headers: ', JSON.stringify(res.headers));
let data = '';
res.setEncoding('utf8');
res.on('data', chunk => {
data += chunk;
});
res.on('end', () => {
console.log('data completed: ', data);
});
}
const req = http.request(options, callback);
req.on('error', e => {
console.log('ops, deu esse erro aqui: ', e.message);
});
req.end();
```
```
vitor@vitor-ThinkPad-T440:/var/www/html/workshop-be-mean/nodejs/http$ node http-request-delete.js
status: 204
headers: {"server":"Cowboy","content-length":"0","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","date":"Tue, 14 Jun 2016 14:16:12 GMT","via":"1.1 vegur"}
data completed:
```
## 5. Escolha uma API externa e crie um script para fazer um GET nela mostrando o resultado com HTML.
```js
'use strict';
const https = require('https');
const http = require('http');
https.get({
hostname: 'www.udacity.com',
path: '/public-api/v0/courses',
agent: false
}, res => {
let body = '';
console.log('status: ' + res.statusCode);
console.log('headers: ', res.headers);
res.on('data', function(data) {
body += data;
});
res.on('end', function() {
createServer(body);
});
});
let createServer = (data) =>{
const dados_curso = JSON.parse(data).courses;
http.createServer((request, response) => {
response.writeHead(200, {'Content-Type': 'text/html'});
let body_html = "<h2> Cursos do uDacity </h2> <ul>";
for(let key in dados_curso){
body_html += "<li> nome do curso: " + dados_curso[key].title + "</li>";
}
body_html += "</ul>";
response.write(body_html);
response.end();
}).listen(3000, function(){
console.log('aguardando na porta 3000');
});
}
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 03 - Exercício
**user:** [angelorubin](https://github.com/angelorubin)
**autor:** Angelo Rogério Rubin
## Por que quando requisitamos ao nosso servidor de *Query String*, **com o Chrome**, ele executa 2 requisições, sendo a última "*vazia*"?
Isso ocorre no *Chrome* porque além da primeira requisição, também é feita uma segunda para o favicon.
Eu creio que não chega a ser um 'problema', pode ser contornado com o seguinte código:
'use strict';
let http = require('http')
, url = require('url');
http.createServer(function(request, response){
if(request.url === '/favicon.ico') {
response.writeHead(404);
response.end();
}
else {
var result = url.parse(request.url, true);
response.writeHead(200, {"Content-Type": "text/html"});
response.write("<html><body>");
response.write("<h1>Be - MEAN</h1>");
response.write("<h2>Query string</h2>");
response.write("<ul>");
console.log(result.query);
for(var key in result.query){
response.write("<li>"+key+" : "+result.query[key]+"</li>");
}
response.write("</ul>");
response.write("</body></html>");
}
response.end();
}).listen(3000, function(){
console.log('Servidor rodando em localhost:3000');
});
## Qual a DIFERENÇA entre o GET e o POST?
* **GET**
- As informações são enviadas como `String` anexada a `URL`
- Limite de tamanho da mensagem a ser enviada
- Envia somente `String`
- Informações enviadas ficam em `cache`
* **POST**
- As informações são encapsuladas junto ao corpo da requisição `HTTP` e não podem ser vistas na `URL`
- Sem limites de comprimento da mensagem enviada
- Envia qualquer tipo de dados
- As informações enviadas **NÃO** ficam gravadas em `cache`
## Crie um Pokemon na nossa API com seu nome, depois modifique seu nome pelo seu User do Github.
PS C:\Projetos\nodejs> node http-request-post.js
postData name=Angelo%20Rubin&description=scravus%20assalariadus&type=ajudant
&height=1.85&defense=300
Tamanho do postData 135
STATUS: 201
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","a
e":"application/json; charset=utf-8","content-length":"170","etag":"W/\"aa-V
2015 17:29:12 GMT","via":"1.1 vegur"}
Dados(s) postado(s): {"__v":0,"name":"Angelo Rubin","description":"scrav
e de pedreiro","attack":100,"height":1.85,"_id":"5672f0e807bbbe11004259f0"}
PS C:\Projetos\nodejs> node http-request-put.js
STATUS: 202
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-typ
e":"application/json; charset=utf-8","content-length":"108","etag":"W/\"6c-UZYkXWB4GWoROquknoOGcw\"","date":"Thu, 17 Dec
2015 17:32:42 GMT","via":"1.1 vegur"}
Dado(s) atualizado(s): {"data":{"ok":1,"nModified":1,"n":1,"lastOp":"6229307015773028353","electionId":"565e25d106dca62
2271891c4"}}
## **Depois faça o DELETE**, criando o script para tal, colocando aqui a resposta.
PS C:\Projetos\nodejs> node http-request-delete.js
STATUS: 204
HEADERS: {"server":"Cowboy","content-length":"0","connection":"close","x-powered-by":"Express","access-control-allow-or
gin":"*","date":"Thu, 17 Dec 2015 17:35:11 GMT","via":"1.1 vegur"}
Dado(s) deletado(s):
## Escolha uma **API externa** e crie um script para fazer um GET nela **mostrando o resultado com HTML**.
**Script
'use strict';
const http = require('http');
http.get({
host:'api.redtube.com'
, path: '/?data=redtube.Videos.searchVideos&search=Anjelica'
}, (response) => {
let body = '';
console.log('STATUS: ' + response.statusCode);
console.log('HEADERS: ' + JSON.stringify(response.headers));
response.on('data', function(data) {
body += data;
});
response.on('end', function() {
let data = JSON.parse(body);
console.log('<ul>');
for (var i = 0, titles = Object.keys(data.videos[0].video).length; i <= titles; i++) {
console.log('<li> ' + data.videos[i].video.title + '</li>');
}
console.log('</ul>');
});
});
**API externa escolhida (api.redtube.com)
PS C:\Projetos\nodejs> node http-get-redtube.js
STATUS: 200
HEADERS: {"server":"nginx","date":"Fri, 18 Dec 2015 12:45:31 GMT","content-type":"application/json;charset=utf-8","trans
fer-encoding":"chunked","connection":"close","set-cookie":["PHPSESSID=62aemcu01o7e411ctie15mg673; path=/"],"expires":"Th
u, 19 Nov 1981 08:52:00 GMT","cache-control":"no-store, no-cache, must-revalidate, post-check=0, pre-check=0","pragma":"
no-cache"}
<ul>
<li> Breakfast In Bed - Anjelica </li>
<li> Quartet - Anjelica, Maria, Lola, Tess</li>
<li> Anal passion and pain</li>
<li> Jb Teen Sodomy 04 - 002</li>
<li> garota muito safada</li>
<li> Krystal Boyd,,Slammed</li>
<li> Burn My Passion - Anjelica</li>
<li> Krysta</li>
<li> Stunning Anjelica masturbates to orgasm</li>
<li> Krystal Boyd</li>
<li> Big ass pussy ball sucking</li>
<li> Gorgeous model ballslicking</li>
<li> Abbie christmas Anal</li>
<li> Natural tits teenie buttfucking</li>
</ul> | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 03 - Exercício
**user:** [rxon7](https://github.com/rxon7)
**autor:** rony souza
### 1. Por que quando requisitamos ao nosso servidor de *Query String*, **com o Chrome**, ele executa 2 requisições, sendo a última "*vazia*"?
Porque o Chrome faz a primeira requisição para puxar os dados da `Querystring` e a segunda requisição é para puxar o `fav.icon` do site
### 2. Qual a `DIFERENÇA` entre o `GET` e o `POST`?
**GET**
- Possui uma capacidade de 1024 caracteres, é utilizado quando se quer passar poucas informações para realizar uma pesquisa ou simplismente passar informações para outra página/api através da URL. O resultado desse método é armazenado no cache do client, ou seja, fica no histórico do navegador.
**POST**
- O método POST utiliza ao URI ao contrário de GET, para enviar as informações ao servidor. A URI não é retornável ao cliente, o que torna esse método mais seguro, pois não expõe as informações enviadas no navegador. Esse método não possui limite como o GET para envio, quando é feita uma requisição POST uma conexão paralela é aberta e os dados são enviados por ela. Essa requisição deverá ser formatada no corpo da mensagem como uma querystring, além de enviar no headers seu formato e tamanho.
### 3. Crie um Pokemon na nossa API com seu nome, depois modifique seu nome pelo seu User do Github.
```
'use strict'
const http = require('http')
, queryString = require('querystring')
, postData = queryString.stringify({
name: 'Ronyclay barreto de souza'
, type: 'aluno'
})
, options = {
host: 'webschool-io.herokuapp.com'
, method: 'post'
, path: '/api/pokemons'
, headers: {
'Content-Type': 'application/x-www-form-urlencoded'
, 'Content-Length': postData.length
}
};
var req = http.request(options, res => {
let chunck = '';
res.on('data', data => chunck += data);
res.on('end', () => console.log('Fim!'));
})
req.on('error', e => console.log('Erro!' + e));
req.write(postData);
req.end();
```
```
'use strict'
const http = require('http')
, queryString = require('querystring')
, postData = queryString.stringify({
name: 'rxon7'
, type: 'aluno'
})
, options = {
host: 'webschool-io.herokuapp.com'
, method: 'put'
, path: '/api/pokemons/56b80d13ff45d31100182506'
, headers: {
'Content-Type': 'application/x-www-form-urlencoded'
, 'Content-Length': postData.length
}
};
var req = http.request(options, res => {
let chunck = '';
res.on('data', data => chunck += data);
res.on('end', () => console.log('Fim!'));
})
req.on('error', e => console.log('Erro!' + e));
req.write(postData);
req.end();
```
### 4. Depois faça o DELETE, criando o script para tal, colocando aqui a resposta.
```js
'use strict';
const http = require('http');
const querystring = require('querystring');
const options = {
host: 'webschool-io.herokuapp.com',
method: 'DELETE',
path: '/api/pokemons/56b80d13ff45d31100182506',
};
function callback(res) {
console.log('STATUS:' + res.statusCode);
console.log('HEADERS:' + JSON.stringify(res.headers));
let data = '';
res.setEncoding('utf8');
res.on('data', (chunk) => {
data += chunk;
});
res.on('end', () => {
console.log('Dados finalizados:', data)
});
}
const req = http.request(options, callback);
req.on('error', (e) => {
console.log('Erro:' + e.message);
});
req.end();
```
### 5. Escolha uma **API externa** e crie um script para fazer um GET nela **mostrando o resultado com HTML**.
```js
'use strict';
const http = require('http');
var RESP = {
name: 'resposta'
};
http.get({
hostname : 'pokeapi.co',
path: '/api/v2/language/4/',
},(response) => {
let body = "";
console.log('STATUS:'+ response.statusCode);
console.log(response.headers);
response.on('data', data=>{
body += data;
});
response.on('end', function(){
RESP.result = JSON.parse(body).name;
});
});
http.createServer((request, response)=>{
response.writeHead(200, {'Content-Type': 'text/html'});
response.write('<h1>'+RESP.result+'<h1>');
response.end();
}).listen(3000, function(){
console.log('rodando nas porta 3000');
});
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 03 - Exercício
**user:** charles7421
**autor:** Charles de Freitas Garcia
## Por que quando requisitamos ao nosso servidor de *Query String*, **com o Chrome**, ele executa 2 requisições, sendo a última "*vazia*"?
É um bug conhecido, sempre envia 2 requisições. Uma originalmente do URL requisitada e uma do Favicon.ico da URL originalmente requisitada. No Chorme, acontece sempre 2 requisições, já no Firefox, somente na primeira vez.
## Qual a DIFERENÇA entre o GET e o POST?
GET solicita algum recurso ou arquivo da URL no caso.
POST envia dados para ser processados e/ou inseridos.
Resumidamente, GET é pra pegar do servidor, e POST é pra inserir no servidor.
## Crie um Pokemon na nossa API com seu nome, depois modifique seu nome pelo seu User do Github.
```js
'use strict';
const http = require('http');
const querystring = require('querystring');
const postData = querystring.stringify({
name: 'Charles de Freitas Garcia'
});
const options = {
host: 'webschool-io.herokuapp.com',
method: 'POST',
path: '/api/pokemons',
headers: {
'Content-Type': 'application/x-www-form-urlencoded',
'Content-Length' : postData.length
}
};
function callback(res) {
console.log('STATUS:' + res.statusCode);
console.log('HEADERS:' + JSON.stringify(res.headers));
let data = '';
res.setEncoding('utf8');
res.on('data', (chunk) => {
data += chunk;
});
res.on('end', () => {
console.log('Dados finalizados:', data)
});
}
const req = http.request(options, callback);
req.on('error', (e) => {
console.log('Erro:' + e.message);
});
req.write(postData);
req.end();
```
Modificando ...
```js
'use strict';
const http = require('http');
const querystring = require('querystring');
const postData = querystring.stringify({
name: 'charles7421'
});
const options = {
host: 'webschool-io.herokuapp.com',
method: 'PUT',
path: '/api/pokemons/56fc80391333451100ec3524',
headers: {
'Content-Type': 'application/x-www-form-urlencoded',
'Content-Length' : postData.length
}
};
function callback(res) {
console.log('STATUS:' + res.statusCode);
console.log('HEADERS:' + JSON.stringify(res.headers));
let data = '';
res.setEncoding('utf8');
res.on('data', (chunk) => {
data += chunk;
});
res.on('end', () => {
console.log('Dados finalizados:', data)
});
}
const req = http.request(options, callback);
req.on('error', (e) => {
console.log('Erro:' + e.message);
});
req.write(postData);
req.end();
```
## **Depois faça o DELETE**, criando o script para tal, colocando aqui a resposta.
```js
'use strict';
const http = require('http');
const querystring = require('querystring');
const options = {
host: 'webschool-io.herokuapp.com',
method: 'DELETE',
path: '/api/pokemons/56fc8b1823545b11006d8868',
};
function callback(res) {
console.log('STATUS:' + res.statusCode);
console.log('HEADERS:' + JSON.stringify(res.headers));
let data = '';
res.setEncoding('utf8');
res.on('data', (chunk) => {
data += chunk;
});
res.on('end', () => {
console.log('Dados finalizados:', data)
});
}
const req = http.request(options, callback);
req.on('error', (e) => {
console.log('Erro:' + e.message);
});
req.end();
```
## Escolha uma **API externa** e crie um script para fazer um GET nela **mostrando o resultado com HTML**.
Acesso a API Star Wars
http://swapi.co/api/people/1/
```js
'use strict';
const http = require('http');
const options = {
host: 'swapi.co',
method: 'GET',
path: '/api/people/1/'
};
function callback(res) {
console.log('STATUS:' + res.statusCode);
console.log('HEADERS:' + res.headers);
let data = '';
res.setEncoding('utf8');
res.on('data', (chunk) => {
data += chunk;
});
res.on('end', () => {
console.log('Dados finalizados:', data)
});
}
const req = http.request(options, callback);
req.on('error', (e) => {
console.log('Erro:' + e.message);
});
req.end();
```
```html
STATUS:200
HEADERS:[object Object]
Dados finalizados: {
"name": "Luke Skywalker",
"height": "172",
"mass": "77",
"hair_color": "blond",
"skin_color": "fair",
"eye_color": "blue",
"birth_year": "19BBY",
"gender": "male",
"homeworld": "http://swapi.co/api/planets/1/",
"films": [
"http://swapi.co/api/films/6/",
"http://swapi.co/api/films/3/",
"http://swapi.co/api/films/2/",
"http://swapi.co/api/films/1/",
"http://swapi.co/api/films/7/"
],
"species": [
"http://swapi.co/api/species/1/"
],
"vehicles": [
"http://swapi.co/api/vehicles/14/",
"http://swapi.co/api/vehicles/30/"
],
"starships": [
"http://swapi.co/api/starships/12/",
"http://swapi.co/api/starships/22/"
],
"created": "2014-12-09T13:50:51.644000Z",
"edited": "2014-12-20T21:17:56.891000Z",
"url": "http://swapi.co/api/people/1/"
}
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# NodeJS - Aula 03 - Exercício
autor: Wellerson Roberto
## 1) Por que quando requisitamos ao nosso servidor de Query String, com o Chrome, ele executa 2 requisições sendo a última "vazia"?
A segunda requisição feita pelo Google Chrome é a requisição pra buscar o favicon.ico.
## 2) Qual a DIFERENÇA entre o GET e o POST?
Os verbos **GET** e **POST** são usados para propósitos distintos. Enquanto o **GET** é usado para requisitar dados, o **POST** é usado para enviar dados para o servidor. Outras diferenças:
* O **GET** envia os dados pela URL, portanto é menos seguro. O **POST** faz o envio pelo **body** da requisição.
* O **GET** pode ser cacheado e ficar no histórico do navegador, o **POST** não.
* Como os dados do **GET** são enviados pela URL, ele fica limitado ao tamanho da URL. Por **POST** não.
## 3) Crie um POKEMON na nossa API com o seu nome, depois modifique seu nome pelo User do GitHub, colocando aqui a resposta de cada passo.
```
'use strict'
const http = require('http')
, queryString = require('querystring')
, postData = queryString.stringify({
name: 'Wellerson Roberto Alves Nobrega'
, type: 'aluno'
})
, options = {
host: 'webschool-io.herokuapp.com'
, method: 'post'
, path: '/api/pokemons'
, headers: {
'Content-Type': 'application/x-www-form-urlencoded'
, 'Content-Length': postData.length
}
};
var req = http.request(options, res => {
let chunck = '';
res.on('data', data => chunck += data);
res.on('end', () => console.log('Fim!'));
})
req.on('error', e => console.log('Erro!' + e));
req.write(postData);
req.end();
```
```
'use strict'
const http = require('http')
, queryString = require('querystring')
, postData = queryString.stringify({
name: 'wellerson010'
, type: 'aluno'
})
, options = {
host: 'webschool-io.herokuapp.com'
, method: 'put'
, path: '/api/pokemons/56b80d13ff45d31100182506'
, headers: {
'Content-Type': 'application/x-www-form-urlencoded'
, 'Content-Length': postData.length
}
};
var req = http.request(options, res => {
let chunck = '';
res.on('data', data => chunck += data);
res.on('end', () => console.log('Fim!'));
})
req.on('error', e => console.log('Erro!' + e));
req.write(postData);
req.end();
```
## 4) Depois faça o DELETE, criado o script para tal, colocando aqui a resposta.
```
'use strict'
const http = require('http')
, options = {
host: 'webschool-io.herokuapp.com'
, method: 'delete'
, path: '/api/pokemons/56b80d13ff45d31100182506'
};
var req = http.request(options, res => {
let chunck = '';
res.on('data', data => chunck += data);
res.on('end', () => console.log('Fim!'));
})
req.on('error', e => console.log('Erro!' + e));
req.end();
```
## 5) Escolha uma API externa e crie um script para fazer um GET nela mostrando o resultado em HTML.
```
'use strict';
const http = require('http');
const app = {
createServer: () => {
this.server = http.createServer((req, response) => {
response.writeHead(200, { 'Content-Type': 'text/html' });
http.get(app.optionsRequest, res => {
let data = '';
res.on('data', chunck => data += chunck);
res.on('end', () => {
var json = JSON.parse(data)
, html = app.htmlHelper.build(json.data);
response.write(html);
response.end();
});
});
});
},
htmlHelper: {
build: (data) => {
var html = '';
html += app.htmlHelper.buildHeader();
html += app.htmlHelper.buildBody(data);
html += app.htmlHelper.buildFooter();
return html;
},
buildHeader: () => {
var html = '<!doctype html>' +
'<html>' +
'<head>' +
'<meta charset="utf-8">' +
'<title>Usando a API do Deezer!</title>' +
'</head>' +
'<body>'
return html;
},
buildBody: data => {
var html = ''
, i = 0
, length = 0;
for (i = 0, length = data.length ; i < length; i++) {
html += '<div>' +
'<p>' + data[i].title + '</p>' +
'<img src="' + data[i].album.cover + '"/>' +
'<audio controls><source src="' + data[i].preview + '" type="audio/mpeg" preload="none"/></audio>' +
'</div></hr>';
};
return html;
},
buildFooter: () =>{ return '</body></html>' }
},
optionsRequest: {
hostname: 'api.deezer.com',
path: '/search?q=eminem'
},
listen: () => this.server.listen(3000, () => console.log('Estou pronto!')),
server: null
};
app.createServer();
app.listen();
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 03 - Exercício
**user:** [lucasduarte](https://lucasduarte.github.io)
**autor:** Lucas Duarte Anício
## Por que quando requisitamos ao nosso servidor de *Query String*, **com o Chrome**, ele executa 2 requisições, sendo a última "*vazia*"?
A requisição extra é executada a fim de obter o "favicon"
## Qual a DIFERENÇA entre o GET e o POST?
**GET** Serve para requisitar dados de uma determinada aplicação
**POST** É utilizado para submeter dados que posteriormente serão processados pela aplicação
## Crie um Pokemon na nossa API com seu nome, depois modifique seu nome pelo seu User do Github.
**Código Criação**
```js
'use strict';
const http = require('http');
const querystring = require('querystring');
const postData = querystring.stringify({
name: 'Lucas Duarte',
type: 'aluno'
});
const options = {
host: 'webschool-io.herokuapp.com'
, method: 'POST'
, path: '/api/pokemons'
, headers: {
'Content-Type': 'application/x-www-form-urlencoded'
, 'Content-Length': postData.length
}
};
function callback(res) {
console.log('STATUS: ' + res.statusCode);
console.log('HEADERS: ' + JSON.stringify(res.headers));
let data = '';
res.setEncoding('utf8');
res.on('data', (chunk) => {
data += chunk;
});
res.on('end', () => {
console.log('Dados finalizados: ', data)
});
}
const req = http.request(options, callback);
req.on('error', (e) => {
console.log('ERRO: ' + e.message);
});
req.write(postData);
req.end();
```
**Resultado**
```
STATUS: 201
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"79","etag":"W/\"4f-y2YhmPP6F7gUftFszWtHnQ\"","date":"Fri, 01 Apr 2016 23:19:03 GMT","via":"1.1 vegur"}
Dados finalizados: {"__v":0,"name":"Lucas Duarte","type":"aluno","_id":"56ff01e72ac29c1100ab422f"}
```
**Código Alteração**
```js
'use strict';
const http = require('http');
const querystring = require('querystring');
const postData = querystring.stringify({
name: 'Lucas Duarte Anicio',
});
const options = {
host: 'webschool-io.herokuapp.com'
, method: 'PUT'
, path: '/api/pokemons/56ff01e72ac29c1100ab422f'
, headers: {
'Content-Type': 'application/x-www-form-urlencoded'
, 'Content-Length': postData.length
}
};
function callback(res) {
console.log('STATUS: ' + res.statusCode);
console.log('HEADERS: ' + JSON.stringify(res.headers));
let data = '';
res.setEncoding('utf8');
res.on('data', (chunk) => {
data += chunk;
});
res.on('end', () => {
console.log('Dados finalizados: ', data)
});
}
const req = http.request(options, callback);
req.on('error', (e) => {
console.log('ERRO: ' + e.message);
});
req.write(postData);
req.end();
```
**Resultado**
```
STATUS: 202
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"90","etag":"W/\"5a-Qb9Gax1+1bghS2ST/U8Bkg\"","date":"Fri, 01 Apr 2016 23:25:11 GMT","via":"1.1 vegur"}
Dados finalizados: {"data":{"ok":1,"nModified":0,"n":1,"lastOp":"0","electionId":"56ee12f2563048036a1e77e7"}}
```
## **Depois faça o DELETE**, criando o script para tal, colocando aqui a resposta.
**Código**
```js
'use strict';
const http = require('http');
const querystring = require('querystring');
const postData = querystring.stringify({
});
const options = {
host: 'webschool-io.herokuapp.com'
, method: 'DELETE'
, path: '/api/pokemons/56ff01e72ac29c1100ab422f'
};
function callback(res) {
console.log('STATUS: ' + res.statusCode);
console.log('HEADERS: ' + JSON.stringify(res.headers));
let data = '';
res.setEncoding('utf8');
res.on('data', (chunk) => {
data += chunk;
});
res.on('end', () => {
console.log('Dados finalizados: ', data)
});
}
const req = http.request(options, callback);
req.on('error', (e) => {
console.log('ERRO: ' + e.message);
});
req.write(postData);
req.end();
```
**Resultado**
```
STATUS: 204
HEADERS: {"server":"Cowboy","content-length":"0","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","date":"Fri, 01 Apr 2016 23:28:02 GMT","via":"1.1 vegur"}
Dados finalizados:
```
## Escolha uma **API externa** e crie um script para fazer um GET nela **mostrando o resultado com HTML**.
**Código**
```js
'use strict';
const http = require('http');
const options = {
host: 'correiosapi.apphb.com'
, path: '/cep/76873274'
};
function callback(res) {
console.log('STATUS: ' + res.statusCode);
console.log('HEADERS: ' + JSON.stringify(res.headers));
let data = '';
res.setEncoding('utf8');
res.on('data', (chunk) => {
data += chunk;
});
res.on('end', () => {
console.log('Dados finalizados: ', data)
});
}
const req = http.request(options, callback);
req.on('error', (e) => {
console.log('ERRO: ' + e.message);
});
req.end();
```
**Resultado**
```
STATUS: 200
HEADERS: {"server":"nginx","date":"Fri, 01 Apr 2016 23:31:09 GMT","content-type":"application/json; charset=utf-8","content-length":"120","connection":"close","cache-control":"no-cache","pragma":"no-cache","expires":"-1"}
Dados finalizados: {"cep":"76873274","tipoDeLogradouro":"Rua","logradouro":"Juriti","bairro":"Setor 02","cidade":"Ariquemes","estado":"RO"}
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
## Node.js - Aula 03 - Exercício
**user:** tuchedsf - https://github.com/tuchedsf
**autor:** Diego Santos Ferreira
## Por que quando requisitamos ao nosso servidor de *Query String*, **com o Chrome**, ele executa 2 requisições, sendo a última "*vazia*"?
Pois o comportamento do chrome é sempre após processar uma requisição, ele efetuar outra requisição para recuperar o favicon.ico do site.
## Qual a DIFERENÇA entre o GET e o POST?
Os dois métodos são utilizados para fazer requisição ao servidor, sendo a principal diferença a visibilidade, uma vez que o get utiliza a própria url para passagem de parâmetros enquanto o post encapsulada junto ao corpo da requisição os parâmetros e não é visível.
As requisições get geralmente são utilizadas ao requisitar algum recurso geralmente para leitura, já as requisições post são mais utilizadas para passar parâmetros e realizar uma requisição de atualização de dados etc. Uma requisição get também por utilizar da url possui uma limitação de 1024 caracteres.
## Crie um Pokemon na nossa API com seu nome, depois modifique seu nome pelo seu User do Github.
```
MacBook-Air-Diego:nodejs diego$ node http-create-pokemon.js
postData name=Diego%20Ferreira&type=turtle
Tamanho do postData 33
STATUS: 201
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"82","etag":"W/\"52-2IF24hW3OLiEBLEVp0CKdA\"","date":"Sun, 28 Feb 2016 11:49:39 GMT","via":"1.1 vegur"}
Dados finalizados: {"__v":0,"name":"Diego Ferreira","type":"turtle","_id":"56d2ded2fb64951100bc36de"}
```
##### Conferencia API
```
http://webschool-io.herokuapp.com/api/pokemons/56d2ded2fb64951100bc36de
{
"_id": "56d2ded2fb64951100bc36de",
"name": "Diego Ferreira",
"type": "turtle",
"__v": 0
}
```
#### Alteração Pokemon:
```
MacBook-Air-Diego:nodejs diego$ node http-alter-pokemon-api.js
postData name=tuchedsf&type=turtle
Tamanho do postData 25
STATUS: 202
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"108","etag":"W/\"6c-9YlCYIxXYr/SQVQ13QTnEg\"","date":"Sun, 28 Feb 2016 12:03:00 GMT","via":"1.1 vegur"}
Dados finalizados: {"data":{"ok":1,"nModified":1,"n":1,"lastOp":"6256311270459310082","electionId":"565e25d106dca622271891c4"}}
```
##### Conferencia API
```
http://webschool-io.herokuapp.com/api/pokemons/56d2ded2fb64951100bc36de
{
"_id": "56d2ded2fb64951100bc36de",
"name": "tuchedsf",
"type": "turtle",
"__v": 0
}
```
## **Depois faça o DELETE**, criando o script para tal, colocando aqui a resposta.
```
MacBook-Air-Diego:nodejs diego$ node http-delete-pokemon-api.js
postData name=tuchedsf&type=turtle
Tamanho do postData 25
STATUS: 204
HEADERS: {"server":"Cowboy","content-length":"0","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","date":"Sun, 28 Feb 2016 12:08:53 GMT","via":"1.1 vegur"}
Dados finalizados:
```
##### Conferencia API
```
http://webschool-io.herokuapp.com/api/pokemons/56d2ded2fb64951100bc36de
null
```
## Escolha uma **API externa** e crie um script para fazer um GET nela **mostrando o resultado com HTML**.
API: http://postmon.com.br/ -> consulta cep
```
MacBook-Air-Diego:nodejs diego$ node http-get-fipe-api-2.js
STATUS: 200
HEADERS: {"date":"Tue, 01 Mar 2016 01:21:54 GMT","content-type":"application/json","content-length":"278","connection":"close","set-cookie":["__cfduid=db7fb08890a2bca695abcae005db5bebe1456795314; expires=Wed, 01-Mar-17 01:21:54 GMT; path=/; domain=.postmon.com.br; HttpOnly"],"access-control-allow-origin":"*","cache-control":"public, max-age=2592000","x-cache-status":"MISS","cf-cache-status":"HIT","expires":"Thu, 31 Mar 2016 01:21:54 GMT","server":"cloudflare-nginx","cf-ray":"27c8cb7d762b385e-ATL"}
<html><body><h1>Dados do Endereço</h1><ul>
<li>bairro:Major Lage de Cima</li>
<li>cidade:Itabira</li>
<li>cep:35900394</li>
<li>logradouro:Rua Topázio</li>
<li>estado_info:[object Object]</li>
<li>cidade_info:[object Object]</li>
<li>estado:MG</li>
</ul></body></html>
```
## Bibliografia
http://marceloweb.info/principais-diferencas-entre-os-metodos-http-get-e-post/
http://professortorres.com.br/diferenca-entre-os-metodos-get-e-post/
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 03 - Exercício
**User:** [daniofilho](https://github.com/daniofilho)
**Autor:** Dânio Filho
**Date:** 1452720577119
# 1. Por que quando requisitamos ao nosso servidor de Query String, **com o Chrome**, ele executa 2 requisições, sendo a última "vazia"?
O Chrome, além da requisição que foi solicitada, ele realiza uma requisição de um favicon. Como não passamos isso, ele retorna vazio.
# 2. Qual a **DIFERENÇA** entre o **GET** e o **POST**?
** GET **
O GET foi feito para se enviar pedidos para receber informações de uma url, e é usado para enviar parâmetros via URL. Ele possui uma limitação de caracteres em seu envio de 1024 caracteres, o que torna o conteúdo bem limitado.
** POST **
Já o POST foi feito para enviar informações e não apenas consulta-las (como é o caso do GET). Os parâmetros não são enviados via url e o limite do POST é "ilimitado", sendo esse limite sendo apenas definido via servidor, o que geralmente garante o POST de bastante informação sem problema nenhum.
# 3. Crie um Pokemon na nossa API com o seu nome, depois modifique seu nome pelo seu user do Github, colocando aqui a resposta de cada passo.
~~~ js
//Criando o "Pokemon"
STATUS: 201
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"78","etag":"W/\"4e-GtkDpHj2/UkF+JW96KfJcQ\"","date":"Wed, 13 Jan 2016 21:49:14 GMT","via":"1.1 vegur"}
Dados finalizados: {"__v":0,"name":"Danio Filho","type":"aluno","_id":"5696c65a2f90f71100f42eca"}
//Removendo
STATUS: 202
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"108","etag":"W/\"6c-BsH4onU2gQgfl729cawThQ\"","date":"Wed, 13 Jan 2016 21:52:44 GMT","via":"1.1 vegur"}
Dados finalizados: {"data":{"ok":1,"nModified":1,"n":1,"lastOp":"6239393325560889345","electionId":"565e25d106dca622271891c4"}}
~~~
# 4. Depois faça o DELETE, criando o script para tal, colocndo aqui a resposta.
~~~ js
//Excluindo
STATUS: 204
HEADERS: {"server":"Cowboy","content-length":"0","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","date":"Wed, 13 Jan 2016 21:53:47 GMT","via":"1.1 vegur"}
Dados finalizados:
~~~
# 5. Escolha uma API externa e crie um script para fazer um GET nela mostrando o resultado em HTML.
~~~ js
//API
host: 'pokeapi.co',
path: '/api/v1/type/?limit=10&offset=1'
//Retorno
STATUS: 200
HEADERS: {"server":"nginx/1.1.19","date":"Wed, 13 Jan 2016 23:35:29 GMT","content-type":"application/json","transfer-encoding":"chunked","connection":"close","vary":"Accept","x-frame-options":"SAMEORIGIN","cache-control":"s-maxage=360, max-age=360"}
<ul>
<li>Fighting</li>
<li>Flying</li>
<li>Poison</li>
<li>Ground</li>
<li>Rock</li>
<li>Bug</li>
<li>Ghost</li>
<li>Steel</li>
<li>Fire</li>
<li>Water</li>
</ul>
~~~
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 03 - Exercício
**user:** [augustoody](https://github.com/AugustoOdy)
**autor:** Augusto Ody
**date:** 1455192829487
## Por que quando requisitamos ao nosso servidor de *Query String*, **com o Chrome**, ele executa 2 requisições, sendo a última "*vazia*"?
A segunda requisição envia o `favicon.ico`, e a primeira é a requição feita.
## Qual a DIFERENÇA entre o GET e o POST?
**GET:** por seus parametros serem passados pela URL, são armazenados no histórico do navegador, por este mesmo motivo podem ser facilmente alterados e só aceitão caracteres ASCII. Alguns servidores podem acabar limitando o seu tamanho, aceitando uma URL de até 2048 caracteres.
**POST:** seus parametros não são salvos no historico, e podem ser enviados arquivos para o servidor. Não possuem restrição de tamanho, aceitando tambem tipos binários.
## Crie um Pokemon na nossa API com seu nome, depois modifique seu nome pelo seu User do Github.
# Criação (POST)
```sh
postData name=Augusto%20Ody&type=aluno
postData.length 29
Status 201
Headers {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"78","etag":"W/\"4e-ZxC702mgB6lts1cpp/xCuQ\"","date":"Thu, 11 Feb 2016 22:29:16 GMT","via":"1.1 vegur"}
Dados finalizados {"__v":0,"name":"Augusto Ody","type":"aluno","_id":"56bd0b3b2c257311009b5721"}
```
# Modificação (PUT)
```sh
postData name=augustoody
postData.length 15
Status 202
Headers {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"108","etag":"W/\"6c-frcmbtrtM2TSD81obiZtjw\"","date":"Thu, 11 Feb 2016 22:30:47 GMT","via":"1.1 vegur"}
Dados finalizados {"data":{"ok":1,"nModified":1,"n":1,"lastOp":"6250164601028083713","electionId":"565e25d106dca622271891c4"}}
```
## **Depois faça o DELETE**, criando o script para tal, colocando aqui a resposta.
```sh
Status 204
Headers {"server":"Cowboy","content-length":"0","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","date":"Thu, 11 Feb 2016 22:34:41 GMT","via":"1.1 vegur"}
Dados finalizados
```
## Escolha uma **API externa** e crie um script para fazer um GET nela **mostrando o resultado com HTML**.
Consulta na API do Star Wars
```js
'use strict';
const http = require('http');
http.get({
host: 'swapi.co'
, path: '/api/people/'
, port: 80
, agent: false
}, (res) => {
let body = '';
console.log('statusCode', res.statusCode);
console.log('Headers', JSON.stringify(res.headers));
res.on('data', (data) => {
body += data;
});
res.on('end', () => {
body = JSON.parse(body);
console.log('<html><body>');
console.log('<h1>Be - Mean</h1>');
console.log('<h2>Query String</h2>');
console.log('<ul>');
body.results.forEach((data) => {
console.log("<li>"+data.name+"</li>");
});
console.log('</ul>');
console.log('</body><html>');
});
res.on('error', (e) => {
console.log('error', e.message);
});
});
```
Resultado:
```
statusCode 200
Headers {"date":"Thu, 11 Feb 2016 23:19:17 GMT","content-type":"application/json","transfer-encoding":"chunked","connection":"close","set-cookie":["__cfduid=dbecc884cb514f3f89b22f6320b74455d1455232756; expires=Fri, 10-Feb-17 23:19:16 GMT; path=/; domain=.swapi.co; HttpOnly"],"etag":"\"1aa90088e8812cbe8a55f2990a9e0e15\"","vary":"Accept, Cookie","x-frame-options":"SAMEORIGIN","allow":"GET, HEAD, OPTIONS","via":"1.1 vegur","server":"cloudflare-nginx","cf-ray":"2733c71872aa1623-LIM"}
<html><body>
<h1>Be - Mean</h1>
<h2>Query String</h2>
<ul>
<li>Luke Skywalker</li>
<li>C-3PO</li>
<li>R2-D2</li>
<li>Darth Vader</li>
<li>Leia Organa</li>
<li>Owen Lars</li>
<li>Beru Whitesun lars</li>
<li>R5-D4</li>
<li>Biggs Darklighter</li>
<li>Obi-Wan Kenobi</li>
</ul>
</body><html>
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 03 - Exercício
**user:** [felipelopesrita](https://github.com/felipelopesrita)
**autor:** Felipe José Lopes Rita
## Por que quando requisitamos ao nosso servidor de *Query String*, **com o Chrome**, ele executa 2 requisições, sendo a última "*vazia*"?
Porque além da requisição original, o navergador gera uma segunda requisição em que procura o favicon.ico do site
## Qual a DIFERENÇA entre o GET e o POST?
No verbo GET, a query string é anexada diretamente à URL da requisição. Assim, as informações a serem enviadas só podem ser strings, além de possuir um limite de tamanho máximo da mensagem a ser enviada. Este verbo também guarda as informações enviadas em cache.
De forma contrária, o verbo POST anexa as informações no corpo do documento da requisição, possibilitando que sejam enviados outros tipos de dados além de strings e também que não exista um limite de tamanho para a requisição. Outro ponto importante é que esse método não guarda as informações enviadas em cache.
## Crie um Pokemon na nossa API com seu nome, depois modifique seu nome pelo seu User do Github.
**Cria com meu nome**
```js
STATUS: 201
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"84","etag":"W/\"54-2gzvZ0bdq2GrzbiKW4KACA\"","date":"Wed, 24 Feb 2016 03:46:24 GMT","via":"1.1 vegur"}
Dados finalizados: {"__v":0,"name":"Felipe J. L. Rita","type":"aluno","_id":"56cd279073a6431100ba1de8"}
```
**Modifica pelo usuario do GitHub**
```js
STATUS: 202
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"108","etag":"W/\"6c-c3SDbmIqBjmtNxn+Zvbfyw\"","date":"Wed, 24 Feb 2016 03:49:37 GMT","via":"1.1 vegur"}
Dados finalizados: {"data":{"ok":1,"nModified":1,"n":1,"lastOp":"6254699785844948993","electionId":"565e25d106dca622271891c4"}}
```
## **Depois faça o DELETE**, criando o script para tal, colocando aqui a resposta.
```js
STATUS: 204
HEADERS: {"server":"Cowboy","content-length":"0","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","date":"Wed, 24 Feb 2016 03:53:37 GMT","via":"1.1 vegur"}
Dados finalizados:
```
## Escolha uma **API externa** e crie um script para fazer um GET nela **mostrando o resultado com HTML**.
```js
STATUS: 200
HEADERS: {"server":"nginx/1.1.19","date":"Wed, 24 Feb 2016 04:42:21 GMT","content-type":"application/json","transfer-encoding":"chunked","connection":"close","vary":"Accept","x-frame-options":"SAMEORIGIN","cache-control":"s-maxage=360, max-age=360"}
Resposta:
...
<ul>
<li>Water</li>
<li>Grass</li>
<li>Electric</li>
<li>Ice</li>
<li>Dragon</li>
</ul>
...
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 03 - Exercício
**user:** [higordiego](https://github.com/higordiego)
**autor:** Higor Diego Alves Ferreira Pinheiro
## Por que quando requisitamos ao nosso servidor de *Query String*, **com o Chrome**, ele executa 2 requisições, sendo a última "*vazia*"?
Uma para puxar o que foi feito na requisição e a segunda para o pegar o (favicon) *.icon
## Qual a DIFERENÇA entre o GET e o POST?
No get, as informações são enviadas como string com anexo na url, no post a informação é encapsuladas junto ao corpo da requisição não vista na url.
## Crie um Pokemon na nossa API com seu nome, depois modifique seu nome pelo seu User do Github.
```js
'use strict'
const http = require('http')
, querystring = require('querystring')
, postData = querystring.stringify({
name: 'Higor Diego'
, type: 'Aluno'
});
const options = {
host: 'webschool-io.herokuapp.com'
, method: 'POST'
, path: '/api/pokemons'
, headers: {
'Content-Type': 'application/x-www-form-urlencoded'
, 'Content-length' : postData.length
}
};
function callback(res){
let data = ''
res.setEncoding('utf8');
res.on('data', (chunk)=>{
data += chunk;
});
res.on('end',()=>{
console.log('Dados Cadastrados:',data);
});
}
const req = http.request(options, callback);
req.write(postData)
req.end();
```
---
```js
'use strict'
const http = require('http')
, querystring = require('querystring')
, postData = querystring.stringify({
name: 'higordiego'
, type: 'Aluno'
});
const options = {
host: 'webschool-io.herokuapp.com'
, method: 'PUT'
, path: '/api/pokemons/56afcba6339d291100f39691'
, headers: {
'Content-Type': 'application/x-www-form-urlencoded'
, 'Content-length' : postData.length
}
};
function callback(res){
let data = ''
res.setEncoding('utf8');
res.on('data', (chunk)=>{
data += chunk;
});
res.on('end',()=>{
console.log('Dados Alterados:',data);
});
}
const req = http.request(options, callback);
req.write(postData)
req.end();
```
## **Depois faça o DELETE**, criando o script para tal, colocando aqui a resposta.
```js
'use strict'
const http = require('http')
, querystring = require('querystring')
, postData = querystring.stringify({
name: 'higordiego'
, type: 'Aluno'
});
const options = {
host: 'webschool-io.herokuapp.com'
, method: 'PUT'
, path: '/api/pokemons/56afcba6339d291100f39691'
, headers: {
'Content-Type': 'application/x-www-form-urlencoded'
, 'Content-length' : postData.length
}
};
function callback(res){
let data = ''
res.setEncoding('utf8');
res.on('data', (chunk)=>{
data += chunk;
});
res.on('end',()=>{
console.log('Dados Alterados:',data);
});
}
const req = http.request(options, callback);
req.write(postData)
req.end();
```
## Escolha uma **API externa** e crie um script para fazer um GET nela **mostrando o resultado com HTML**.
```html
<body>
<h1>CEP</h1>
<ul>
<li>Santana</li>
<li>Rua Voluntários da Pátria</li>
<li>02011200</li>
<li>SP</li>
</ul>
</body>
</html>
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 03 - Exercício
**user:** [Marcos](https://github.com/marks88martinez)
**autor:** Marcos Antonio Martinez Florentin
## Por que quando requisitamos ao nosso servidor de *Query String*, **com o Chrome**, ele executa 2 requisições, sendo a última "*vazia*"?
O Chrome, além da requisição que foi solicitada executa outro GET para buscar o favicon.icon e como não encontra retorna vazio.
## Qual a DIFERENÇA entre o GET e o POST?
- **GET** é o metodo de leitura, para obter dados passados na querystring.
- **POST** é o metodo de inserção, cria um objeto.
## Crie um Pokemon na nossa API com seu nome, depois modifique seu nome pelo seu User do Github.
```js
STATUS: 201
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"58","etag":"W/\"3a-sjfHHWizYlGIpgfVrIYyiw\"","date":"Wed, 09 Mar 2016 04:53:26 GMT","via":"1.1 vegur"}
Dados finalizados: {"__v":0,"name":"Mateus","_id":"56dfac46526e7011009a58ec"}
```
```js
STATUS:201
HEADERS{"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"83","etag":"W/\"53-u5Z+ipnVIkEOCLIKIHGoPA\"","date":"Wed, 13 Jul 2016 14:22:59 GMT","via":"1.1 vegur"}
Datos finalizados {"__v":0,"name":"Marcos Martinez","type":"Alumno","_id":"57864ec3d2fdf3110011f462"}
```
## **Depois faça o DELETE**, criando o script para tal, colocando aqui a resposta.
```js
STATUS:204
HEADERS{"server":"Cowboy","content-length":"0","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","date":"Wed, 13 Jul 2016 17:26:58 GMT","via":"1.1 vegur"}
Dados finalizados.
```
## Escolha uma **API externa** e crie um script para fazer um GET nela **mostrando o resultado com HTML**.
```js
'use strict';
const http = require('http'); //libreria que se encarga de la requisiciones
const options = {
host: 'webschool-io.herokuapp.com',
path: '/api/pokemons',
method: 'GET',
headers: {
'User-Agent': 'Chrome',
'Content-Type': 'text/html'
}
};
const req = http.request(options, function(res) {
console.log('STATUS: ' + res.statusCode);
console.log('HEADERS: ' + JSON.stringify(res.headers));
res.setEncoding('utf8');
res.on('data', function (chunk) {
console.log('<html><body><h4> ' +chunk+'</code></body></html>');
});
});
req.on('error', function(e) {
console.log('Error: ' + e.message);
});
req.end();
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 03 - Exercício
**Autor:** Wendell Adriel Luiz Silva - [WendellAdriel](https://github.com/WendellAdriel)
**Data:** 1455144837454
## Por que quando requisitamos ao nosso servidor de Query String, com o Chrome, ele executa 2 requisições, sendo a última "vazia"?
A segunda requisição que o **Chrome** envia é para trazer o `favicon.ico` da aplicação.
## Qual a DIFERENÇA entre o GET e o POST?
- **`GET`**
- Todas informações são enviadas anexadas à `URL`
- Há um limite máximo de caracteres que podem ser enviados
- Dados enviados ficam guardados no `cache` do navegador
- A mensagem é enviada apenas como uma `string`
- **`POST`**
- Todas informações são enviadas junto ao corpo da requisição `HTTP`, protegendo para que os dados não sejam vistos na `URL`
- Não há um limite de caracteres que podem ser enviados
- Os dados enviados não ficam guardados no `cache` do navegador
- Pode enviar outros tipos de dados além de `string`
## Crie um Pokemon na nossa API com seu nome, depois modifique seu nome pelo seu User do Github.
```
postData name=Wendell%20Adriel&type=student
Tamanho do postData 34
STATUS: 201
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"83","etag":"W/\"53-FJJpQe0EvnaiYkm2MUIbNQ\"","date":"Wed, 10 Feb 2016 23:06:28 GMT","via":"1.1 vegur"}
Dados finalizados: {"__v":0,"name":"Wendell Adriel","type":"student","_id":"56bbc27482124e110077f541"}
```
```
STATUS: 202
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"108","etag":"W/\"6c-vTjX0L3EIPEGcUjU9U3wNg\"","date":"Wed, 10 Feb 2016 23:09:16 GMT","via":"1.1 vegur"}
Dados finalizados: {"data":{"ok":1,"nModified":1,"n":1,"lastOp":"6249803432933195777","electionId":"565e25d106dca622271891c4"}}
```
## Depois faça o DELETE, criando o script para tal, colocando aqui a resposta.
```
STATUS: 204
HEADERS: {"server":"Cowboy","content-length":"0","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","date":"Wed, 10 Feb 2016 23:13:59 GMT","via":"1.1 vegur"}
Dados finalizados:
```
## Escolha uma API externa e crie um script para fazer um GET nela mostrando o resultado com HTML.
```js
// Chamada para API
'use strict';
const http = require('http');
http.get({
hostname : 'pokeapi.co'
, path : '/api/v2/pokemon/212/'
, agent : false
}, res => {
let data = '';
console.log('STATUS: ' + res.statusCode);
console.log('HEADERS: ' + JSON.stringify(res.headers));
res.on('data', chunk => {
data += chunk;
});
res.on('end', () => {
let json = JSON.parse(data);
console.log('<h1>' + json.id + ' - ' + json.name + '</h1>');
});
});
// RESPOSTA
STATUS: 200
HEADERS: {"server":"nginx/1.1.19","date":"Wed, 10 Feb 2016 23:39:43 GMT","content-type":"application/json","transfer-encoding":"chunked","connection":"close","vary":"Cookie","x-frame-options":"SAMEORIGIN","allow":"GET, HEAD, OPTIONS"}
<h1>212 - scizor</h1>
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 03 - Exercício
**Autor:** Rafael Crispim Ignácio
**Data:** 1451440020307
## Por que quando requisitamos ao nosso servidor de Query String, com o Chrome, ele executa 2 requisições, sendo a última "vazia"?
Quando executamos uma requisição através do navegador Google Chrome, o mesmo efetua uma requisição adicional buscando pela imagem favicon.ico.
## Qual a DIFERENÇA entre o GET e o POST?
As principais diferenças entre GET e POST são:
- Visibilidade
Enquanto uma requisição GET é enviada no formato de string anexada a URL uma requisição POST é anexada ao corpo do da requisição HTTP.
- Tamanho
As requisições GET, por serem em formato de String, estão limitadas a 255 caracteres já via POST este limite não existe.
- Dados
As requisições GET só podem transitar no padrão ASCII. No POST podemos utilizar do formato UCS, para isto basta utilizar o `enctype` igual a `multipart/form-data`. Além desta questão nas requisições GET podemos enviar informações no formato de texto enquanto no POST também podemos enviar dados binários.
É importante ressaltar que as duas formas são essenciais para enviarmos informações através do protocolo HTTP, cada qual tem a sua finalidade e objetivo.
## Crie um Pokemon na nossa API com seu nome, depois modifique seu nome pelo seu User do Github, colocando aqui a resposta de cada passo.
### CREATE
```js
node nodejs/exercicio.js
STATUS: 201
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"90","etag":"W/\"5a-JSlAXH/uFT9RSDVuDrebeQ\"","date":"Wed, 30 Dec 2015 01:25:34 GMT","via":"1.1 vegur"}
Dados finalizados: {"__v":0,"name":"Rafael Crispim Ignácio","type":"Aluno","_id":"5683328e4bcde71100eaa9ee"}
```
### UPDATE
```js
node nodejs/exercicio.js
STATUS: 202
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"108","etag":"W/\"6c-lHgQ2Bma/0EhCuM+Yp8YVA\"","date":"Wed, 30 Dec 2015 01:26:47 GMT","via":"1.1 vegur"}
Dados finalizados: {"data":{"ok":1,"nModified":1,"n":1,"lastOp":"6233882208210255873","electionId":"565e25d106dca622271891c4"}}
```
## Depois faça o DELETE, criando o script para tal, colocando aqui a resposta.
```js
node nodejs/exercicio.js
STATUS: 204
HEADERS: {"server":"Cowboy","content-length":"0","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","date":"Wed, 30 Dec 2015 01:27:37 GMT","via":"1.1 vegur"}
Dados finalizados:
```
## Escolha uma API externa e crie um script para fazer um GET nela mostrando o resultado com HTML.
- API
[http://pokeapi.co](http://pokeapi.co)
```js
// URL -> http://pokeapi.co/api/v1/pokemon/50
node nodejs/exercicio.js
STATUS: 200
HEADERS: {"server":"nginx/1.1.19","date":"Wed, 30 Dec 2015 01:44:03 GMT","content-type":"application/json","transfer-encoding":"chunked","connection":"close","vary":"Accept","x-frame-options":"SAMEORIGIN","cache-control":"s-maxage=360, max-age=360"}
Resposta: {"abilities": [{"name": "sand-veil", "resource_uri": "/api/v1/ability/8/"}, {"name": "arena-trap", "resource_uri": "/api/v1/ability/71/"}, {"name": "sand-force", "resource_uri": "/api/v1/ability/159/"}], "attack": 55, "catch_rate": 0, "created": "2013-11-03T15:05:41.365518", "defense": 25, "descriptions": [{"name": "diglett_gen_1", "resource_uri": "/api/v1/description/801/"}, {"name": "diglett_gen_1", "resource_uri": "/api/v1/description/798/"}, {"name": "diglett_gen_1", "resource_uri": "/api/v1/description/799/"}, {"name": "diglett_gen_1", "resource_uri": "/api/v1/description/800/"}, {"name": "diglett_gen_1", "resource_uri": "/api/v1/description/802/"}, {"name": "diglett_gen_2", "resource_uri": "/api/v1/description/804/"}, {"name": "diglett_gen_3", "resource_uri": "/api/v1/description/805/"}, {"name": "diglett_gen_3", "resource_uri": "/api/v1/description/806/"}, {"name": "diglett_gen_3", "resource_uri": "/api/v1/description/807/"}, {"name": "diglett_gen_6", "resource_uri": "/api/v1/description/812/"}, {"name": "diglett_gen_6", "resource_uri": "/api/v1/description/813/"}, {"name": "diglett_gen_4", "resource_uri": "/api/v1/description/808/"}, {"name": "diglett_gen_5", "resource_uri": "/api/v1/description/811/"}, {"name": "diglett_gen_4", "resource_uri": "/api/v1/description/809/"}, {"name": "diglett_gen_2", "resource_uri": "/api/v1/description/803/"}, {"name": "diglett_gen_4", "resource_uri": "/api/v1/description/810/"}], "egg_cycles": 0, "egg_groups": [{"name": "Ground", "resource_uri": "/api/v1/egg/5/"}], "ev_yield": "", "evolutions": [{"level": 26, "method": "level_up", "resource_uri": "/api/v1/pokemon/51/", "to": "Dugtrio"}], "exp": 53, "growth_rate": "", "happiness": 0, "height": "2", "hp": 10, "male_female_ratio": "", "modified": "2013-11-23T13:13:25.213302", "moves": [{"learn_type": "level up", "level": 18, "name": "Bulldoze", "resource_uri": "/api/v1/move/523/"}, {"learn_type": "egg move", "name": "Final-gambit", "resource_uri": "/api/v1/move/515/"}, {"learn_type": "machine", "name": "Echoed-voice", "resource_uri": "/api/v1/move/497/"}, {"learn_type": "machine", "name": "Round", "resource_uri": "/api/v1/move/496/"}, {"learn_type": "machine", "name": "Hone-claws", "resource_uri": "/api/v1/move/468/"}, {"learn_type": "egg move", "name": "Memento", "resource_uri": "/api/v1/move/262/"}, {"learn_type": "egg move", "name": "Headbutt", "resource_uri": "/api/v1/move/29/"}, {"learn_type": "egg move", "name": "Reversal", "resource_uri": "/api/v1/move/179/"}, {"learn_type": "machine", "name": "Stealth-rock", "resource_uri": "/api/v1/move/446/"}, {"learn_type": "machine", "name": "Captivate", "resource_uri": "/api/v1/move/445/"}, {"learn_type": "level up", "level": 29, "name": "Mud-bomb", "resource_uri": "/api/v1/move/426/"}, {"learn_type": "machine", "name": "Shadow-claw", "resource_uri": "/api/v1/move/421/"}, {"learn_type": "level up", "level": 26, "name": "Earth-power", "resource_uri": "/api/v1/move/414/"}, {"learn_type": "level up", "level": 23, "name": "Sucker-punch", "resource_uri": "/api/v1/move/389/"}, {"learn_type": "machine", "name": "Natural-gift", "resource_uri": "/api/v1/move/363/"}, {"learn_type": "level up", "level": 7, "name": "Astonish", "resource_uri": "/api/v1/move/310/"}, {"learn_type": "machine", "name": "Sandstorm", "resource_uri": "/api/v1/move/201/"}, {"learn_type": "level up", "level": 21, "name": "Fury-swipes", "resource_uri": "/api/v1/move/154/"}, {"learn_type": "machine", "name": "Aerial-ace", "resource_uri": "/api/v1/move/332/"}, {"learn_type": "machine", "name": "Rock-tomb", "resource_uri": "/api/v1/move/317/"}, {"learn_type": "machine", "name": "Secret-power", "resource_uri": "/api/v1/move/290/"}, {"learn_type": "machine", "name": "Facade", "resource_uri": "/api/v1/move/263/"}, {"learn_type": "egg move", "name": "Uproar", "resource_uri": "/api/v1/move/253/"}, {"learn_type": "egg move", "name": "Beat-up", "resource_uri": "/api/v1/move/251/"}, {"learn_type": "machine", "name": "Rock-smash", "resource_uri": "/api/v1/move/249/"}, {"learn_type": "egg move", "name": "Ancientpower", "resource_uri": "/api/v1/move/246/"}, {"learn_type": "machine", "name": "Sunny-day", "resource_uri": "/api/v1/move/241/"}, {"learn_type": "machine", "name": "Hidden-power", "resource_uri": "/api/v1/move/237/"}, {"learn_type": "egg move", "name": "Pursuit", "resource_uri": "/api/v1/move/228/"}, {"learn_type": "level up", "level": 9, "name": "Magnitude", "resource_uri": "/api/v1/move/222/"}, {"learn_type": "machine", "name": "Frustration", "resource_uri": "/api/v1/move/218/"}, {"learn_type": "machine", "name": "Return", "resource_uri": "/api/v1/move/216/"}, {"learn_type": "machine", "name": "Sleep-talk", "resource_uri": "/api/v1/move/214/"}, {"learn_type": "machine", "name": "Attract", "resource_uri": "/api/v1/move/213/"}, {"learn_type": "machine", "name": "Swagger", "resource_uri": "/api/v1/move/207/"}, {"learn_type": "machine", "name": "Endure", "resource_uri": "/api/v1/move/203/"}, {"learn_type": "machine", "name": "Mud-slap", "resource_uri": "/api/v1/move/189/"}, {"learn_type": "machine", "name": "Sludge-bomb", "resource_uri": "/api/v1/move/188/"}, {"learn_type": "egg move", "name": "Faint-attack", "resource_uri": "/api/v1/move/185/"}, {"learn_type": "machine", "name": "Protect", "resource_uri": "/api/v1/move/182/"}, {"learn_type": "machine", "name": "Curse", "resource_uri": "/api/v1/move/174/"}, {"learn_type": "machine", "name": "Snore", "resource_uri": "/api/v1/move/173/"}, {"learn_type": "machine", "name": "Thief", "resource_uri": "/api/v1/move/168/"}, {"learn_type": "egg move", "name": "Screech", "resource_uri": "/api/v1/move/103/"}, {"learn_type": "machine", "name": "Cut", "resource_uri": "/api/v1/move/15/"}, {"learn_type": "machine", "name": "Substitute", "resource_uri": "/api/v1/move/164/"}, {"learn_type": "level up", "level": 31, "name": "Slash", "resource_uri": "/api/v1/move/163/"}, {"learn_type": "machine", "name": "Rock-slide", "resource_uri": "/api/v1/move/157/"}, {"learn_type": "machine", "name": "Rest", "resource_uri": "/api/v1/move/156/"}, {"learn_type": "machine", "name": "Bide", "resource_uri": "/api/v1/move/117/"}, {"learn_type": "machine", "name": "Double-team", "resource_uri": "/api/v1/move/104/"}, {"learn_type": "machine", "name": "Mimic", "resource_uri": "/api/v1/move/102/"}, {"learn_type": "machine", "name": "Rage", "resource_uri": "/api/v1/move/99/"}, {"learn_type": "machine", "name": "Toxic", "resource_uri": "/api/v1/move/92/"}, {"learn_type": "level up", "level": 19, "name": "Dig", "resource_uri": "/api/v1/move/91/"}, {"learn_type": "machine", "name": "Fissure", "resource_uri": "/api/v1/move/90/"}, {"learn_type": "level up", "level": 40, "name": "Earthquake", "resource_uri": "/api/v1/move/89/"}, {"learn_type": "level up", "level": 15, "name": "Growl", "resource_uri": "/api/v1/move/45/"}, {"learn_type": "machine", "name": "Double-edge", "resource_uri": "/api/v1/move/38/"}, {"learn_type": "machine", "name": "Take-down", "resource_uri": "/api/v1/move/36/"}, {"learn_type": "machine", "name": "Body-slam", "resource_uri": "/api/v1/move/34/"}, {"learn_type": "level up", "level": 24, "name": "Sand-attack", "resource_uri": "/api/v1/move/28/"}, {"learn_type": "level up", "level": 1, "name": "Scratch", "resource_uri": "/api/v1/move/10/"}], "name": "Diglett", "national_id": 50, "pkdx_id": 50, "resource_uri": "/api/v1/pokemon/50/", "sp_atk": 35, "sp_def": 45, "species": "", "speed": 95, "sprites": [{"name": "diglett", "resource_uri": "/api/v1/sprite/51/"}], "total": 0, "types": [{"name": "ground", "resource_uri": "/api/v1/type/5/"}], "weight": "8"}
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 03 - Exercício
**user:** [airton](https://github.com/airton)<br>
**autor:** Airton Vancin Junior<br>
**date:** 1455891128461
## Por que quando requisitamos ao nosso servidor de *Query String*, **com o Chrome**, ele executa 2 requisições, sendo a última "*vazia*"?
A segunda requisiçao é vazia por causa do /favicon.ico
## Qual a DIFERENÇA entre o GET e o POST?
O GET faz uma requisição e retorna alguma coisa, o POST faz a requisiçao e grava os dados que são passados.
## Crie um Pokemon na nossa API com seu nome, depois modifique seu nome pelo seu User do Github.
**POST**
```js
'use strict';
const http = require('http');
const querystring = require('querystring');
const postData = querystring.stringify({
name: 'Airton Vancin Junior'
, type: 'Aluno'
});
console.log("postData", postData);
console.log("Tamanho do postData", postData.length);
const options = {
host: 'webschool-io.herokuapp.com'
, method: 'POST'
, path: '/api/pokemons'
, headers: {
'Content-Type': 'application/x-www-form-urlencoded'
, 'Content-Length': postData.length
}
};
function callback(res) {
console.log('STATUS: ' + res.statusCode);
console.log('HEADERS: ' + JSON.stringify(res.headers));
let data = '';
res.setEncoding('utf8');
res.on('data', (chunk) => {
data += chunk;
});
res.on('end', () => {
console.log('Dados finalizados: ', data)
})
}
const req = http.request(options, callback);
req.on('error', (e) => {
console.log('ERROOOO: ' + e.message);
});
req.write(postData);
req.end();
junior@linux:~/www/be-mean-instagram-nodejs/files/aula03$ node http-request-post.js
postData name=Airton%20Vancin%20Junior&type=Aluno
Tamanho do postData 40
STATUS: 201
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"87","etag":"W/\"57-oqGkGdJmijrlvVY+9QhemQ\"","date":"Sat, 13 Feb 2016 22:49:34 GMT","via":"1.1 vegur"}
Dados finalizados: {"__v":0,"name":"Airton Vancin Junior","type":"Aluno","_id":"56bfb2fdc08f331100525451"}
```
**PUT**
```js
'use strict';
const http = require('http');
const querystring = require('querystring');
const postData = querystring.stringify({
name: 'airton'
});
const options = {
host: 'webschool-io.herokuapp.com'
, method: 'PUT'
, path: '/api/pokemons/56bfb2fdc08f331100525451'
, headers: {
'Content-Type': 'application/x-www-form-urlencoded'
, 'Content-Length': postData.length
}
};
function callback(res) {
console.log('STATUS: ' + res.statusCode);
console.log('HEADERS: ' + JSON.stringify(res.headers));
let data = '';
res.setEncoding('utf8');
res.on('data', (chunk) => {
data += chunk;
});
res.on('end', () => {
console.log('Dados finalizados: ', data)
})
}
const req = http.request(options, callback);
req.on('error', (e) => {
console.log('ERROOOO: ' + e.message);
});
req.write(postData);
req.end();
junior@linux:~/www/be-mean-instagram-nodejs/files/aula03$ node http-request-put.js
STATUS: 202
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"108","etag":"W/\"6c-ug7ULKX01O4OuFsRfIq22w\"","date":"Sat, 13 Feb 2016 22:53:30 GMT","via":"1.1 vegur"}
Dados finalizados: {"data":{"ok":1,"nModified":1,"n":1,"lastOp":"6250912625417256962","electionId":"565e25d106dca622271891c4"}}
```
## **Depois faça o DELETE**, criando o script para tal, colocando aqui a resposta.
```js
'use strict';
const http = require('http');
const querystring = require('querystring');
const options = {
host: 'webschool-io.herokuapp.com'
, method: 'DELETE'
, path: '/api/pokemons/56bfb2fdc08f331100525451'
, headers: {
'Content-Type': 'application/x-www-form-urlencoded'
}
};
function callback(res) {
console.log('STATUS: ' + res.statusCode);
console.log('HEADERS: ' + JSON.stringify(res.headers));
let data = '';
res.setEncoding('utf8');
res.on('data', (chunk) => {
data += chunk;
});
res.on('end', () => {
console.log('Dados finalizados: ', data)
})
}
const req = http.request(options, callback);
req.on('error', (e) => {
console.log('ERROOOO: ' + e.message);
});
req.end();
```
```js
junior@linux:~/www/be-mean-instagram-nodejs/files/aula03$ node http-request-delete.js
STATUS: 204
HEADERS: {"server":"Cowboy","content-length":"0","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","date":"Sat, 13 Feb 2016 22:58:47 GMT","via":"1.1 vegur"}
Dados finalizados:
```
## Escolha uma **API externa** e crie um script para fazer um GET nela **mostrando o resultado com HTML**.
```js
'use strict';
const http = require('http');
const json2html = require('node-json2html');
const options = {
host: 'fipeapi.appspot.com'
, path: '/api/1/carros/veiculos/20.json'
};
function callback(res) {
console.log('STATUS: ' + res.statusCode);
console.log('HEADERS: ' + JSON.stringify(res.headers));
let data = '';
res.setEncoding('utf8');
res.on('data', (chunk) => {
data += chunk;
});
res.on('end', () => {
var transform = {'tag':'li','html':'${fipe_marca}: ${fipe_name} - ${marca} - ${key} - ${id} - ${name}'};
var html = '<ul>';
html += json2html.transform(data,transform);
html += '</ul>';
console.log('JSON: ', data)
console.log('HTML: ', html)
})
}
const req = http.request(options, callback);
req.on('error', (e) => {
console.log('ERROOOO: ' + e.message);
});
req.end();
```
**JSON**
```json
[{"fipe_marca": "Ferrari", "fipe_name": "348 GTS 3.4", "marca": "FERRARI", "key": "348-417", "id": "417", "name": "348 GTS 3.4"}, {"fipe_marca": "Ferrari", "fipe_name": "348 Spider 3.4", "marca": "FERRARI", "key": "348-418", "id": "418", "name": "348 Spider 3.4"}, {"fipe_marca": "Ferrari", "fipe_name": "348 TS/TB 3.4", "marca": "FERRARI", "key": "348-419", "id": "419", "name": "348 TS/TB 3.4"}, {"fipe_marca": "Ferrari", "fipe_name": "355 Berlinetta", "marca": "FERRARI", "key": "355-420", "id": "420", "name": "355 Berlinetta"}, {"fipe_marca": "Ferrari", "fipe_name": "355 Berlinetta F1", "marca": "FERRARI", "key": "355-421", "id": "421", "name": "355 Berlinetta F1"}, {"fipe_marca": "Ferrari", "fipe_name": "355 GTS", "marca": "FERRARI", "key": "355-422", "id": "422", "name": "355 GTS"}, {"fipe_marca": "Ferrari", "fipe_name": "355 GTS F1", "marca": "FERRARI", "key": "355-423", "id": "423", "name": "355 GTS F1"}, {"fipe_marca": "Ferrari", "fipe_name": "355 GTS Spider", "marca": "FERRARI", "key": "355-424", "id": "424", "name": "355 GTS Spider"}, {"fipe_marca": "Ferrari", "fipe_name": "355 GTS Targa", "marca": "FERRARI", "key": "355-425", "id": "425", "name": "355 GTS Targa"}, {"fipe_marca": "Ferrari", "fipe_name": "355 Spider F1", "marca": "FERRARI", "key": "355-426", "id": "426", "name": "355 Spider F1"}, {"fipe_marca": "Ferrari", "fipe_name": "360 Challenge Stradale", "marca": "FERRARI", "key": "360-427", "id": "427", "name": "360 Challenge Stradale"}, {"fipe_marca": "Ferrari", "fipe_name": "360 Modena", "marca": "FERRARI", "key": "360-428", "id": "428", "name": "360 Modena"}, {"fipe_marca": "Ferrari", "fipe_name": "360 Modena F1", "marca": "FERRARI", "key": "360-429", "id": "429", "name": "360 Modena F1"}, {"fipe_marca": "Ferrari", "fipe_name": "360 Spider 400cv", "marca": "FERRARI", "key": "360-430", "id": "430", "name": "360 Spider 400cv"}, {"fipe_marca": "Ferrari", "fipe_name": "360 Spider F1 400cv", "marca": "FERRARI", "key": "360-431", "id": "431", "name": "360 Spider F1 400cv"}, {"fipe_marca": "Ferrari", "fipe_name": "456 GT", "marca": "FERRARI", "key": "456-432", "id": "432", "name": "456 GT"}, {"fipe_marca": "Ferrari", "fipe_name": "456 GTA", "marca": "FERRARI", "key": "456-433", "id": "433", "name": "456 GTA"}, {"fipe_marca": "Ferrari", "fipe_name": "456 M-GT 5.5 V12", "marca": "FERRARI", "key": "456-434", "id": "434", "name": "456 M-GT 5.5 V12"}, {"fipe_marca": "Ferrari", "fipe_name": "550 Maranello", "marca": "FERRARI", "key": "550-435", "id": "435", "name": "550 Maranello"}, {"fipe_marca": "Ferrari", "fipe_name": "575M Maranello F1 V12 515cv", "marca": "FERRARI", "key": "575m-436", "id": "436", "name": "575M Maranello F1 V12 515cv"}, {"fipe_marca": "Ferrari", "fipe_name": "612 Scaglietti F1 V12 540cv", "marca": "FERRARI", "key": "612-3932", "id": "3932", "name": "612 Scaglietti F1 V12 540cv"}, {"fipe_marca": "Ferrari", "fipe_name": "California 3.9 Turbo F1 V8 560cv", "marca": "FERRARI", "key": "california-7179", "id": "7179", "name": "California 3.9 Turbo F1 V8 560cv"}, {"fipe_marca": "Ferrari", "fipe_name": "California F1 V8 460cv", "marca": "FERRARI", "key": "california-5058", "id": "5058", "name": "California F1 V8 460cv"}, {"fipe_marca": "Ferrari", "fipe_name": "F12 Berlinetta 740cv", "marca": "FERRARI", "key": "f12-6463", "id": "6463", "name": "F12 Berlinetta 740cv"}, {"fipe_marca": "Ferrari", "fipe_name": "F430 F1", "marca": "FERRARI", "key": "f430-3812", "id": "3812", "name": "F430 F1"}, {"fipe_marca": "Ferrari", "fipe_name": "F430 SCUDERIA F1", "marca": "FERRARI", "key": "f430-4809", "id": "4809", "name": "F430 SCUDERIA F1"}, {"fipe_marca": "Ferrari", "fipe_name": "F430 Spider F1", "marca": "FERRARI", "key": "f430-4055", "id": "4055", "name": "F430 Spider F1"}, {"fipe_marca": "Ferrari", "fipe_name": "F458 Italia F1 4.5 V8 570cv", "marca": "FERRARI", "key": "f458-6094", "id": "6094", "name": "F458 Italia F1 4.5 V8 570cv"}, {"fipe_marca": "Ferrari", "fipe_name": "F458 Speciale F1 4.5 V8", "marca": "FERRARI", "key": "f458-6912", "id": "6912", "name": "F458 Speciale F1 4.5 V8"}, {"fipe_marca": "Ferrari", "fipe_name": "F458 Spider F1 4.5 V8 570cv", "marca": "FERRARI", "key": "f458-6156", "id": "6156", "name": "F458 Spider F1 4.5 V8 570cv"}, {"fipe_marca": "Ferrari", "fipe_name": "F599 GTB Fiorano F1 6.0 V12 620cv", "marca": "FERRARI", "key": "f599-4289", "id": "4289", "name": "F599 GTB Fiorano F1 6.0 V12 620cv"}, {"fipe_marca": "Ferrari", "fipe_name": "FF F1 6.3 V12 660cv", "marca": "FERRARI", "key": "ff-6095", "id": "6095", "name": "FF F1 6.3 V12 660cv"}]
```
```html
<ul>
<li>Ferrari: 348 GTS 3.4 - FERRARI - 348-417 - 417 - 348 GTS 3.4</li>
<li>Ferrari: 348 Spider 3.4 - FERRARI - 348-418 - 418 - 348 Spider 3.4</li>
<li>Ferrari: 348 TS/TB 3.4 - FERRARI - 348-419 - 419 - 348 TS/TB 3.4</li>
<li>Ferrari: 355 Berlinetta - FERRARI - 355-420 - 420 - 355 Berlinetta</li>
<li>Ferrari: 355 Berlinetta F1 - FERRARI - 355-421 - 421 - 355 Berlinetta F1</li>
<li>Ferrari: 355 GTS - FERRARI - 355-422 - 422 - 355 GTS</li>
<li>Ferrari: 355 GTS F1 - FERRARI - 355-423 - 423 - 355 GTS F1</li>
<li>Ferrari: 355 GTS Spider - FERRARI - 355-424 - 424 - 355 GTS Spider</li>
<li>Ferrari: 355 GTS Targa - FERRARI - 355-425 - 425 - 355 GTS Targa</li>
<li>Ferrari: 355 Spider F1 - FERRARI - 355-426 - 426 - 355 Spider F1</li>
<li>Ferrari: 360 Challenge Stradale - FERRARI - 360-427 - 427 - 360 Challenge Stradale</li>
<li>Ferrari: 360 Modena - FERRARI - 360-428 - 428 - 360 Modena</li>
<li>Ferrari: 360 Modena F1 - FERRARI - 360-429 - 429 - 360 Modena F1</li>
<li>Ferrari: 360 Spider 400cv - FERRARI - 360-430 - 430 - 360 Spider 400cv</li>
<li>Ferrari: 360 Spider F1 400cv - FERRARI - 360-431 - 431 - 360 Spider F1 400cv</li>
<li>Ferrari: 456 GT - FERRARI - 456-432 - 432 - 456 GT</li>
<li>Ferrari: 456 GTA - FERRARI - 456-433 - 433 - 456 GTA</li>
<li>Ferrari: 456 M-GT 5.5 V12 - FERRARI - 456-434 - 434 - 456 M-GT 5.5 V12</li>
<li>Ferrari: 550 Maranello - FERRARI - 550-435 - 435 - 550 Maranello</li>
<li>Ferrari: 575M Maranello F1 V12 515cv - FERRARI - 575m-436 - 436 - 575M Maranello F1 V12 515cv</li>
<li>Ferrari: 612 Scaglietti F1 V12 540cv - FERRARI - 612-3932 - 3932 - 612 Scaglietti F1 V12 540cv</li>
<li>Ferrari: California 3.9 Turbo F1 V8 560cv - FERRARI - california-7179 - 7179 - California 3.9 Turbo F1 V8 560cv</li>
<li>Ferrari: California F1 V8 460cv - FERRARI - california-5058 - 5058 - California F1 V8 460cv</li>
<li>Ferrari: F12 Berlinetta 740cv - FERRARI - f12-6463 - 6463 - F12 Berlinetta 740cv</li>
<li>Ferrari: F430 F1 - FERRARI - f430-3812 - 3812 - F430 F1</li>
<li>Ferrari: F430 SCUDERIA F1 - FERRARI - f430-4809 - 4809 - F430 SCUDERIA F1</li>
<li>Ferrari: F430 Spider F1 - FERRARI - f430-4055 - 4055 - F430 Spider F1</li>
<li>Ferrari: F458 Italia F1 4.5 V8 570cv - FERRARI - f458-6094 - 6094 - F458 Italia F1 4.5 V8 570cv</li>
<li>Ferrari: F458 Speciale F1 4.5 V8 - FERRARI - f458-6912 - 6912 - F458 Speciale F1 4.5 V8</li>
<li>Ferrari: F458 Spider F1 4.5 V8 570cv - FERRARI - f458-6156 - 6156 - F458 Spider F1 4.5 V8 570cv</li>
<li>Ferrari: F599 GTB Fiorano F1 6.0 V12 620cv - FERRARI - f599-4289 - 4289 - F599 GTB Fiorano F1 6.0 V12 620cv</li>
<li>Ferrari: FF F1 6.3 V12 660cv - FERRARI - ff-6095 - 6095 - FF F1 6.3 V12 660cv</li>
</ul>
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 03 - Exercício
**User:** [Cerezini](https://github.com/Cerezini)
**Autor:** Mateus Cerezini Gomes
## Por que quando requisitamos ao nosso servidor de *Query String*, **com o Chrome**, ele executa 2 requisições, sendo a última "*vazia*"?
Porque ele executa outro GET para buscar o ícone da tab (favicon.ico).
## Qual a DIFERENÇA entre o GET e o POST?
- **GET** é o método de leitura (read), deseja-se obter dados, os parâmetros passados na querystring são necessários para realizar a busca.
- **POST** é o método de inserção (create), deseja-se criar um objeto, os parâmetros passados são as informações necessárias para isso.
## Crie um Pokemon na nossa API com seu nome, depois modifique seu nome pelo seu User do Github.
```js
STATUS: 201
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"58","etag":"W/\"3a-sjfHHWizYlGIpgfVrIYyiw\"","date":"Wed, 09 Mar 2016 04:53:26 GMT","via":"1.1 vegur"}
Dados finalizados: {"__v":0,"name":"Mateus","_id":"56dfac46526e7011009a58ec"}
```
```js
STATUS: 202
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"108","etag":"W/\"6c-FVMqgxkhExrRsjHpKb1Ypg\"","date":"Wed, 09 Mar 2016 04:56:36 GMT","via":"1.1 vegur"}
Dados finalizados: {"data":{"ok":1,"nModified":1,"n":1,"lastOp":"6259912239759753217","electionId":"565e25d106dca622271891c4"}}
```
## **Depois faça o DELETE**, criando o script para tal, colocando aqui a resposta.
```js
STATUS: 204
HEADERS: {"server":"Cowboy","content-length":"0","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","date":"Wed, 09 Mar 2016 04:59:20 GMT","via":"1.1 vegur"}
Dados finalizados:
```
## Escolha uma **API externa** e crie um script para fazer um GET nela **mostrando o resultado com HTML**.
```js
STATUS: 200
HEADERS: {"date":"Thu, 10 Mar 2016 05:21:08 GMT","content-type":"application/json","transfer-encoding":"chunked","connection":"close","set-cookie":["__cfduid=dc35e66a7feb7f6b554d6eb228f413c941457587268; expires=Fri, 10-Mar-17 05:21:08 GMT; path=/; domain=.widenet.com.br; HttpOnly"],"access-control-allow-origin":"*","pragma":"no-cache","cache-control":"no-store, no-cache, max-age=2592000","expires":"Sat, 09 Apr 2016 05:21:08 GMT","vary":"Accept-Encoding","server":"cloudflare-nginx","cf-ray":"2814524b2b9818b5-GRU"}
Dados finalizados: <html><body><h1>Busca por CEP</h1><ul><li>status: 1</li><li>code: 06233-030</li><li>state: SP</li><li>city: Osasco</li><li>district: Piratininga</li><li>address: Rua Paula Rodrigues</li></ul></body></html>
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 03 - Exercício
**user:** [gkal19](https://github.com/gkal19)
**autor:** Gabriel Kalani
## Por que quando requisitamos ao nosso servidor de *Query String*, **com o Chrome**, ele executa 2 requisições, sendo a última "*vazia*"?
Isso ocorre, pois o Chrome faz a primeira requisição para puxar os dados da `Querystring` e a segunda requisição é para puxar o `fav.icon` do site
## Qual a DIFERENÇA entre o GET e o POST?
Uma requisição **GET** é enviada como string anexada a URL, enquanto que a requisição **POST** é encapsulada junto ao corpo da requisição HTTP e não pode ser vista.
Já que GET é enviado via URL, então nós sabemos que ela só transporta textos. A requisição POST não tem restrições, pode transportar tanto texto, como dados binários.
## Crie um Pokemon na nossa API com seu nome, depois modifique seu nome pelo seu User do Github.
```js
//Criando Pokémon
postData name=Gabriel%20Kalani
Tamanho do postData 21
STATUS: 201
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*",
"content-type":"application/json; charset=utf-8","content-length":"66","etag":"W/\"42-xME2EVluNCG+T7UcvSd6kA\"",
"date":"Sat, 30 Jan 2016 22:22:56 GMT","via":"1.1 vegur"}
Dados finalizados: {"__v":0,"name":"Gabriel Kalani","_id":"56ad37c0200ef511003a086b"}
//Modificando Pokémon
STATUS: 202
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*",
"content-type":"application/json; charset=utf-8","content-length":"108","etag":"W/\"6c-gWA7CuZscvFTWzd9tLFHDw\"",
"date":"Sat, 30 Jan 2016 22:26:05 GMT","via":"1.1 vegur"}
Dados finalizados: {"data":{"ok":1,"nModified":1,"n":1,"lastOp":"6245710367754813441","electionId":"565e25d106dca622271891c4"}}
```
## **Depois faça o DELETE**, criando o script para tal, colocando aqui a resposta.
```js
HEADERS: {"server":"Cowboy","content-length":"0","connection":"close","x-powered-by":"Express",
"access-control-allow-origin":"*",
"date":"Sat, 30 Jan 2016 22:28:35 GMT","via":"1.1 vegur"}
Dados finalizados:
```
## Escolha uma **API externa** e crie um script para fazer um GET nela **mostrando o resultado com HTML**.
```html
STATUS: 200
HEADERS: {"content-type":"text/html","date":"Sat, 30 Jan 2016 22:28:35 GMT","connection":"close","transfer-encoding":"chunked"}
Dados finalizados:
<html><body><h1>Be MEAN - Instagram</h1></html></body>
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 03 - Exercício
**Autor:** Ednilson Amaral
**Data:** 1450656297212
## Por que quando requisitamos ao nosso servidor de Query String, com o Chrome, ele executa 2 requisições, sendo a última "vazia"?
Isso ocorre porque o Chrome faz duas requisições, sendo uma delas para trazer os dados da requisição do usuário a segunda requisição para pegar o `favicon.ico`.
## Qual a DIFERENÇA entre o GET e o POST?
Uma das diferenças entre o método `GET` e `POST` é sua visibilidade. Enquanto a cada nova requisição `GET` é enviada como string junto a URL, a cada nova requisição `POST` é encapsulada junto ao corpo da requisição HTTP e não pode ser visualizada pelo usuário na URL.
Outras características que as tornam diferentes são:
* Tamanho: a string em um `GET` não pode conter mais que 255 caracteres; `POST` não há limitações;
* Performance: `GET` é mais rápida e mais simples; `POST` tem um perda de tempo, devido ao encapsulamento dos dados;
* Tipos: `GET` é apenas textos; `POST` não tem restrições, texto ou dados binários;
* Bookmarks: `GET` é possível salvar a URL nos seus favoritos, já que a requisição é armazenada em cache; `POST` não é possível;
* Método HTML Padrão: `GET` é o padrão de formulários; para utilizar o método `POST` em formulários é preciso especficiar no atributo `method` o valor `POST`;
* Dados: `GET` limitadas ao padrão ASCII; `POST` é possível utilizar o atributo *enctype* com o valor *multipart/form-data*, além do padrão UCS.
## Crie um Pokemon na nossa API com seu nome, depois modifique seu nome pelo seu User do Github, colocando aqui a resposta de cada passo.
### Criando
```
ednilson@EDNILSON-NB:/var/www/workshop-be-mean/nodejs$ node http-request-post-ednilson.js
postData name=Ednilson%20Amaral&type=dev%20frontend
Tamanho do postData 42
STATUS: 201
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"89","etag":"W/\"59-tHhf5TYro7igA37y6tizcQ\"","date":"Mon, 21 Dec 2015 00:27:04 GMT","via":"1.1 vegur"}
Dados finalizados: {"__v":0,"name":"Ednilson Amaral","type":"dev frontend","_id":"56774758a173d8110083eb0e"}
```
### Modificando
```
ednilson@EDNILSON-NB:/var/www/workshop-be-mean/nodejs$ node http-request-put-ednilson.js
STATUS: 202
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"108","etag":"W/\"6c-Vc6BWVMoCTknBc0PvTN65Q\"","date":"Mon, 21 Dec 2015 00:30:15 GMT","via":"1.1 vegur"}
Dados finalizados: {"data":{"ok":1,"nModified":1,"n":1,"lastOp":"6230527873111818241","electionId":"565e25d106dca622271891c4"}}
```
## Depois faça o DELETE, criando o script para tal, colocando aqui a resposta.
```
ednilson@EDNILSON-NB:/var/www/workshop-be-mean/nodejs$ node http-request-delete-ednilson.js
STATUS: 204
HEADERS: {"server":"Cowboy","content-length":"0","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","date":"Mon, 21 Dec 2015 00:31:53 GMT","via":"1.1 vegur"}
Dados finalizados:
```
## Escolha uma API externa e crie um script para fazer um GET nela mostrando o resultado com HTML.
A API externa escolhida foi a **pokeapi.co**, já utiliza em aula anteriormente.
O arquivo `http-get-api-externa.js` contém:
```js
'use strict';
const http = require('http');
const json2html = require('node-json2html');
http.get({
hostname: 'pokeapi.co',
path: '/api/v1/pokemon/1/',
agent: false
},function(response){
let body = '';
console.log('STATUS: '+response.statusCode);
console.log('HEADERS: '+JSON.stringify(response.headers));
response.on('data', function(data){
body += data;
});
response.on('end', function(){
var transform = {'tag':'div','html':'${name}'};
var html = json2html.transform(body,transform);
console.log('RESPOSTA: ', html);
});
});
```
Após o script para fazer uma `GET` nela o resultado foi:
```
ednilson@EDNILSON-NB:/var/www/workshop-be-mean/nodejs$ node http-get-api-externa.js
STATUS: 200
HEADERS: {"server":"nginx/1.1.19","date":"Mon, 21 Dec 2015 02:18:34 GMT","content-type":"application/json","transfer-encoding":"chunked","connection":"close","vary":"Accept","x-frame-options":"SAMEORIGIN","cache-control":"s-maxage=360, max-age=360"}
RESPOSTA: <div>Bulbasaur</div>
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
```md
# Node.js - Aula 03 - Exercício
**user:** [josecarlosweb](https://github.com/josecarloweb)
**autor:** JOSE CARLOS DA SILVA DE CARVALHO
## Por que quando requisitamos ao nosso servidor de *Query String*, **com o Chrome**, ele executa 2 requisições, sendo a última "*vazia*"?
A segunda requisição realizada pelo chrome é uma requisição GET pelo _favincon.ico_
## Qual a DIFERENÇA entre o GET e o POST?
Uma requisição GET possui por padrão argumentos expostos na URL (Ex. www.site.com.br/?var=valor). Há um tamanho limitado para a requisição GET (255 caracteres). Ele também é o tipo de requisição padrão do HTML.
Uma requisição POST possui seus argumentos encapsulados na mensagem HTTP. A requisição POST não pode transportar somente texto, podendo ser enviados arquivos/binários.
## Crie um Pokemon na nossa API com seu nome, depois modifique seu nome pelo seu User do Github.
**Criando o Pokemon**
node http-request-post.js
STATUS: 201
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"84","etag":"W/\"54-sJ+lyj1X1KVDI81lGmOzhw\"","date":"Sat, 19 Dec 2015 18:53:13 GMT","via":"1.1 vegur"}
Dados finalizados: {"__v":0,"name":"Carlos Carvalho","type":"student","_id":"5675a799addf2e11003746ec"}
**Editando**
node http-request-put.js
STATUS: 202
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"108","etag":"W/\"6c-89O7HQ1nsBoqvhBp6xk+Mg\"","date":"Sat, 19 Dec 2015 18:54:03 GMT","via":"1.1 vegur"}
Dados finalizados: {"data":{"ok":1,"nModified":1,"n":1,"lastOp":"6230070149857148929","electionId":"565e25d106dca622271891c4"}}
## **Depois faça o DELETE**, criando o script para tal, colocando aqui a resposta.
**Código**
//file http-request-delete
'use strict';
const http = require('http');
const querystring = require('querystring');
const postData = querystring.stringify({
name: 'Megaloaníaco de plantão',
});
const options = {
host: 'webschool-io.herokuapp.com',
method: 'DELETE',
path: '/api/pokemons/5672e0e007bbbe11004259ee',
headers: {
'Content-Type': 'application/x-www-form-urlencoded',
'Content-Length': postData.length
}
};
[callbacks, req e afins igual aos demais]
**Uso**
node http-request-delete.js
STATUS: 204
HEADERS: {"server":"Cowboy","content-length":"0","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","date":"Sat, 19 Dec 2015 18:56:25 GMT","via":"1.1 vegur"}
## Escolha uma **API externa** e crie um script para fazer um GET nela **mostrando o resultado com HTML**.
API externa: fipeapi.appspot.com
Pacote extra: node-json2tml
**Código**
//file http-get-localhost-querystring
'use strict';
const http = require('http');
const json2html = require('node-json2html');
var retorno = '';
http.get({
hostname: 'fipeapi.appspot.com',
path: '/api/1/carros/marcas.json',
port: 80,
agent: false
},function(response){
let body = '';
console.log('STATUS: '+response.statusCode);
console.log('HEADERS: '+JSON.stringify(response.headers));
response.on('data', function(data){
body += data;
});
response.on('end', function(){
var transform = {'tag':'div','html':'${name} fipe_name ${fipe_name}'};
var html = json2html.transform(body,transform);
console.log('RESPOSTA: ', html);
});
});
**Saída**
node http-get-fipe.js
STATUS: 200
HEADERS: {"cache-control":"no-cache","content-type":"application/json; charset=utf-8","date":"Sat, 19 Dec 2015 19:52:18 GMT","server":"Google Frontend","content-length":"7524","connection":"close"}
RESPOSTA: <div>AUDI fipe_name Audi</div><div>BMW fipe_name BMW</div><div>CITROEN fipe_name Citroën</div><div>FIAT fipe_name Fiat</div><div>FORD fipe_name Ford</div><div>CHEVROLET fipe_name GM - Chevrolet</div><div>HONDA fipe_name Honda</div><div>HYUNDAI fipe_name Hyundai</div><div>KIA fipe_name Kia Motors</div><div>MERCEDES-BENZ fipe_name Mercedes-Benz</div><div>MITSUBISHI fipe_name Mitsubishi</div><div>NISSAN fipe_name Nissan</div><div>PEUGEOT fipe_name Peugeot</div><div>RENAULT fipe_name Renault</div><div>SUZUKI fipe_name Suzuki</div><div>TOYOTA fipe_name Toyota</div><div>VOLVO fipe_name Volvo</div><div>VOLKSWAGEN fipe_name VW - VolksWagen</div><div>ACURA fipe_name Acura</div><div>AGRALE fipe_name Agrale</div><div>ALFA ROMEO fipe_name Alfa Romeo</div><div>AM GEN fipe_name AM Gen</div><div>ASIA MOTORS fipe_name Asia Motors</div><div>ASTON MARTIN fipe_name ASTON MARTIN</div><div>BRM fipe_name BRM</div><div>BUGGY fipe_name Buggy</div><div>BUGRE fipe_name Bugre</div><div>CADILLAC fipe_name Cadillac</div><div>CBT JIPE fipe_name CBT Jipe</div><div>CHANA fipe_name CHANA</div><div>CHANGAN fipe_name CHANGAN</div><div>CHERY fipe_name CHERY</div><div>CHRYSLER fipe_name Chrysler</div><div>CROSS LANDER fipe_name Cross Lander</div><div>DAEWOO fipe_name Daewoo</div><div>DAIHATSU fipe_name Daihatsu</div><div>DODGE fipe_name Dodge</div><div>EFFA fipe_name EFFA</div><div>ENGESA fipe_name Engesa</div><div>ENVEMO fipe_name Envemo</div><div>FERRARI fipe_name Ferrari</div><div>FIBRAVAN fipe_name Fibravan</div><div>FOTON fipe_name FOTON</div><div>FYBER fipe_name Fyber</div><div>GEELY fipe_name GEELY</div><div>GREAT WALL fipe_name GREAT WALL</div><div>GURGEL fipe_name Gurgel</div><div>HAFEI fipe_name HAFEI</div><div>ISUZU fipe_name Isuzu</div><div>JAC fipe_name JAC</div><div>JAGUAR fipe_name Jaguar</div><div>JEEP fipe_name Jeep</div><div>JINBEI fipe_name JINBEI</div><div>JPX fipe_name JPX</div><div>LADA fipe_name Lada</div><div>LAMBORGHINI fipe_name LAMBORGHINI</div><div>LAND ROVER fipe_name Land Rover</div><div>LEXUS fipe_name Lexus</div><div>LIFAN fipe_name LIFAN</div><div>LOBINI fipe_name LOBINI</div><div>LOTUS fipe_name Lotus</div><div>MAHINDRA fipe_name Mahindra</div><div>MASERATI fipe_name Maserati</div><div>MATRA fipe_name Matra</div><div>MAZDA fipe_name Mazda</div><div>MERCURY fipe_name Mercury</div><div>MG fipe_name MG</div><div>MINI fipe_name MINI</div><div>MIURA fipe_name Miura</div><div>PLYMOUTH fipe_name Plymouth</div><div>PONTIAC fipe_name Pontiac</div><div>PORSCHE fipe_name Porsche</div><div>RAM fipe_name RAM</div><div>RELY fipe_name RELY</div><div>ROLLS-ROYCE fipe_name Rolls-Royce</div><div>ROVER fipe_name Rover</div><div>SAAB fipe_name Saab</div><div>SATURN fipe_name Saturn</div><div>SEAT fipe_name Seat</div><div>SHINERAY fipe_name SHINERAY</div><div>SMART fipe_name smart</div><div>SSANGYONG fipe_name SSANGYONG</div><div>SUBARU fipe_name Subaru</div><div>TAC fipe_name TAC</div><div>TROLLER fipe_name Troller</div><div>WAKE fipe_name Wake</div><div>WALK fipe_name Walk</div>
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 03 - Exercício
**user:** [FranciscoValerio](https://github.com/FranciscoValerio)
**autor:** Francisco Henrique Ruiz Valério
## Por que quando requisitamos ao nosso servidor de *Query String*, **com o Chrome**, ele executa 2 requisições, sendo a última "*vazia*"?
- usando o resultado da requisição e mostrando no console, podemos identificar que a segunda requisição é feita pelo webkit para o favicon.ico. Pois o mesmo não está sendo fornecido pela nossa aplicação.
## Qual a DIFERENÇA entre o GET e o POST?
**GET**
- Possui uma capacidade de 1024 caracteres, é utilizado quando se quer passar poucas informações para realizar uma pesquisa ou simplismente passar informações para outra página/api através da URL. O resultado desse método é armazenado no cache do client, ou seja, fica no histórico do navegador.
**POST**
- O método POST utiliza ao URI ao contrário de GET, para enviar as informações ao servidor. A URI não é retornável ao cliente, o que torna esse método mais seguro, pois não expõe as informações enviadas no navegador. Esse método não possui limite como o GET para envio, quando é feita uma requisição POST uma conexão paralela é aberta e os dados são enviados por ela. Essa requisição deverá ser formatada no corpo da mensagem como uma querystring, além de enviar no headers seu formato e tamanho.
## Crie um Pokemon na nossa API com seu nome, depois modifique seu nome pelo seu User do Github.
**INCLUSÃO**
node .\http-request-post.js
STATUS:201
HEADERS:{"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"85","etag":"W/\"55-OO2mIv68nmeRSifU8w4Vmw\"","date":"Mon, 21 Dec 2015 22:33:11 GMT","via":"1.1 vegur"}
Dados finalizados: {"__v":0,"name":"Francisco Henrique","type":"aluno","_id":"56787e27da0b041100ff4dc9"}
**ALTERAÇÃO**
node .\http-request-put.js
STATUS:202
HEADERS:{"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"108","etag":"W/\"6c-4F/GbPdOma8/l74KTQEnxQ\"","date":"Mon, 21 Dec 2015 23:32:01 GMT","via":"1.1 vegur"}
Dados finalizados: {"data":{"ok":1,"nModified":1,"n":1,"lastOp":"6230883951670460417","electionId":"565e25d106dca622271891c4"}}
## **Depois faça o DELETE**, criando o script para tal, colocando aqui a resposta.
node .\http-request-delete.js
STATUS:204
HEADERS:{"server":"Cowboy","content-length":"0","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","date":"Mon, 21 Dec 2015 23:33:31 GMT","via":"1.1 vegur"}
Dados finalizados:
## Escolha uma **API externa** e crie um script para fazer um GET nela **mostrando o resultado com HTML**.
**CONSULTADO API (http://fipeapi.appspot.com/)**
node .\http-get-fipe.js
STATUS:200
HEADERS:{"cache-control":"no-cache","content-type":"application/json; charset=utf-8","date":"Tue, 22 Dec 2015 00:55:16 GMT","server":"Google Frontend","content-length":"1032","connection":"close"}
Dados finalizados: [{"fipe_marca": "Fiat", "fipe_codigo": "2014-1", "name": "2014 Gasolina", "marca": "FIAT", "key": "2014-1", "veiculo": "Palio 1.0 ECONOMY Fire Flex 8V 4p", "id": "2014-1"}, {"fipe_marca": "Fiat", "fipe_codigo": "2013-1", "name": "2013 Gasolina", "marca": "FIAT", "key": "2013-1", "veiculo": "Palio 1.0 ECONOMY Fire Flex 8V 4p", "id": "2013-1"}, {"fipe_marca": "Fiat", "fipe_codigo": "2012-1", "name": "2012 Gasolina", "marca": "FIAT", "key": "2012-1", "veiculo": "Palio 1.0 ECONOMY Fire Flex 8V 4p", "id": "2012-1"}, {"fipe_marca": "Fiat", "fipe_codigo": "2011-1", "name": "2011 Gasolina", "marca": "FIAT", "key": "2011-1", "veiculo": "Palio 1.0 ECONOMY Fire Flex 8V 4p", "id": "2011-1"}, {"fipe_marca": "Fiat", "fipe_codigo": "2010-1", "name": "2010 Gasolina", "marca": "FIAT", "key": "2010-1", "veiculo": "Palio 1.0 ECONOMY Fire Flex 8V 4p", "id": "2010-1"}, {"fipe_marca": "Fiat", "fipe_codigo": "2009-1", "name": "2009 Gasolina", "marca": "FIAT", "key": "2009-1", "veiculo": "Palio 1.0 ECONOMY Fire Flex 8V 4p", "id": "2009-1"}]
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**user:** [falconeric](https://github.com/falconeric)
**autor:** Eric Lessa
## Por que quando requisitamos ao nosso servidor de *Query String*, **com o Chrome**, ele executa 2 requisições, sendo a última "*vazia*"?
Nesta requisição vazia o chrome faz um request do favicon.
## Qual a DIFERENÇA entre o GET e o POST?
**GET** Solicita dados a um recurso especificado.
**POST** Envia dados para serem processados em um recurso especificado.
### GET
Envia a query string através da URL.
>/test/demo_form.asp?name1=value1&name2=value2
* requisições via GET podem ser cacheadas
* permanecem no histórico do browser
* podem ser favoritadas
* nunca devem ser usadas para informar dados sensíveis, Ex. password
* possui restrição no tamanho
* deve ser usado apenas para recuperar dados
### POST
A query string é enviada no corpo da mensagem HTTP.
>POST /test/demo_form.asp HTTP/1.1
Host: w3schools.com
name1=value1&name2=value2
* Post requests nunca são cacheados
* não permanecem no histórico do browser
* não podem ser favoritados
* não possuem restrições em relação ao seu tamanho
## Crie um Pokemon na nossa API com seu nome, depois modifique seu nome pelo seu User do Github.
```
elcarvalho:be-mean-modulo-nodejs ericlessa$ node http-request-post.js
STATUS 201
HEADERS {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"77","etag":"W/\"4d-P2rkHtNv9Zh6eZfjzWTxCQ\"","date":"Mon, 20 Jun 2016 21:36:09 GMT","via":"1.1 vegur"}
Dados finalizados: {"__v":0,"name":"Eric Lessa","type":"Aluno","_id":"576861c9952453110092d990"}
elcarvalho:be-mean-modulo-nodejs ericlessa$ node http-request-put.js
STATUS 202
HEADERS {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"108","etag":"W/\"6c-qEl5GKr3i3oBfZfSLk56lg\"","date":"Mon, 20 Jun 2016 21:44:46 GMT","via":"1.1 vegur"}
Dados finalizados: {"data":{"ok":1,"nModified":1,"n":1,"lastOp":"6298393815292051457","electionId":"576451dfece94f32689e021d"}}
```
## **Depois faça o DELETE**, criando o script para tal, colocando aqui a resposta.
```
'use strict';
const http = require('http');
const options = {
host: 'webschool-io.herokuapp.com'
, path: '/api/pokemons/576861c9952453110092d990'
, method: 'DELETE'
, headers: {
'Content-Type': 'application/x-www-form-urlencoded'
}
};
function callback(res) {
console.log('STATUS', res.statusCode);
console.log('HEADERS', JSON.stringify(res.headers));
let data = '';
res.setEncoding('utf-8');
res.on('data', (chunk) => {
data += chunk;
});
res.on('end', () => {
console.log('Dados finalizados: ', data);
});
}
const req = http.request(options, callback);
req.on('error', (e) => {
console.log('ERROR: ', e.message);
});
req.end();
elcarvalho:be-mean-modulo-nodejs ericlessa$ node http-request-delete.js
STATUS 204
HEADERS {"server":"Cowboy","content-length":"0","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","date":"Mon, 20 Jun 2016 21:49:
```
## Escolha uma **API externa** e crie um script para fazer um GET nela **mostrando o resultado com HTML**.
```
'use strict';
const http = require('http');
const options = {
host: 'api.usa.gov'
, path: '/jobs/search.json?query=developer'
};
let html = '';
function callback(res) {
let data = '';
res.setEncoding('utf8');
res.on('data', (chunk) => {
data += chunk;
});
res.on('end', () => {
data = JSON.parse(data);
html = '<html><body>';
data.forEach((e) => {
html += '<ul>';
html += '<li>Vaga: '+ e.position_title +'</li>';
html += '<li>Empresa: '+ e.organization_name +'</li>';
html += '<li>Faixa Salarial: '+ e.minimum +'~'+ e.maximum +'</li>';
html += '<li>Detalhes: '+ e.url +'</li>';
html += '</ul>';
});
html += '</body></html>';
});
}
const req = http.request(options, callback);
req.on('error', (e) => {
console.log('ERROOOO: ' + e.message);
});
req.end();
http.createServer(function(request, response){
response.writeHead(200, {'Content-type': 'text/html'});
response.write(html);
response.end();
}).listen(3000, function(){
console.log('Servidor rodando em localhost:3000');
});
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 03 - Exercício
autor: Bruno Lima da Silva
## 1. Por que quando requisitamos ao nosso servidor de Query String, com o Chrome, ele executa 2 requisições, sendo a última "vazia"?
A segunda requisição é feita pelo webkit solicitando favicon.ico e retorna vazia pois a aplicação não possui favicon
## 2. Qual a DIFERENÇA entre o GET e o POST?
GET solicita um determiado recurso servindo como método serguro e não deve ser usado para disperar uma ação.
POST utiliza as informações enviadas no corpo da requisição para criar um novo revurso e também pode ser utilizado para processamentos que não são diretamente relacionados a um recurso.
## 3. Crie um Pokemon na nossa API com seu nome, depois modifique seu nome pelo seu User do Github, colocando aqui a resposta de cada passo.
```js
'use strict';
const http = require('http');
const queryString = require('querystring');
const postData = queryString.stringify({
name: 'Bruno Lima da Silva',
type: 'Developer'
});
console.log('postData', postData);
console.log('Tamanho do postData', postData.length);
const options = {
host: 'webschool-io.herokuapp.com',
method: 'POST',
path: '/api/pokemons',
headers: {
'Content-Type': 'application/x-www-form-urlencoded',
'Content-Length': postData.length
}
};
function callback(response) {
console.log('STATUS: ' + response.statusCode);
console.log('HEADERS: ' + JSON.stringify(response.headers));
let data = '';
response.setEncoding('utf8');
response.on('data', (chunk) => {
data += chunk;
});
response.on('end', () => {
console.log('Dados finalizados', data);
});
}
const request = http.request(options, callback)
request.on('error', (error) => {
console.log('Erro' + error.message);
});
request.write(postData);
request.end();
```
```js
postData name=Bruno%20Lima%20da%20Silva&type=Developer
Tamanho do postData 45
STATUS: 201
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"90","etag":"W/\"5a-J4m44+PW7rFjlXfYKZgYXA\"","date":"Thu, 10 Nov 2016 04:59:59 GMT","via":"1.1 vegur"}
Dados finalizados {"__v":0,"name":"Bruno Lima da Silva","type":"Developer","_id":"5823fecec55c8f00121aea4f"}
```
```js
'use strict';
const http = require('http');
const queryString = require('querystring');
const postData = queryString.stringify({
name: 'blsdotrocks',
});
console.log('postData', postData);
console.log('Tamanho do postData', postData.length);
const options = {
host: 'webschool-io.herokuapp.com',
method: 'PUT',
path: '/api/pokemons/5823f259c55c8f00121aea4a',
headers: {
'Content-Type': 'application/x-www-form-urlencoded',
'Content-Length': postData.length
}
};
function callback(response) {
console.log('STATUS: ' + response.statusCode);
console.log('HEADERS: ' + JSON.stringify(response.headers));
let data = '';
response.setEncoding('utf8');
response.on('data', (chunk) => {
data += chunk;
});
response.on('end', () => {
console.log('Dados finalizados', data);
});
}
const request = http.request(options, callback)
request.on('error', (error) => {
console.log('Erro' + error.message);
});
request.write(postData);
request.end();
```
```js
postData name=blsdotrocks
Tamanho do postData 16
STATUS: 202
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"121","etag":"W/\"79-OQ1I/gqDw8NPAMka9b82vw\"","date":"Thu, 10 Nov 2016 05:00:11 GMT","via":"1.1 vegur"}
Dados finalizados {"data":{"ok":1,"nModified":1,"n":1,"opTime":{"ts":"6351200116073824257","t":0},"electionId":"7fffffff0000000000000000"}}
```
## 4. Depois faça o DELETE, criando o script para tal, colocando aqui a resposta.
```js
'use strict';
const http = require('http');
const options = {
host: 'webschool-io.herokuapp.com',
method: 'DELETE',
path: '/api/pokemons/5823fecec55c8f00121aea4f',
headers: {
'Content-Type': 'application/x-www-form-urlencoded'
}
};
function callback(response) {
console.log('STATUS: ' + response.status);
console.log('HEADERS: ' + JSON.stringify(response.headers));
let data = '';
response.setEncoding('utf8');
response.on('data', (chunk) => {
data += chunk;
});
response.on('end', () => {
console.log('Dados finalizados' + data);
});
}
const request = http.request(options, callback);
request.on('error', (error) => {
console.log('Error' + error.message);
});
request.end();
```
```js
STATUS: 204
HEADERS: {"server":"Cowboy","content-length":"0","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","date":"Thu, 10 Nov 2016 05:01:32 GMT","via":"1.1 vegur"}
Dados finalizados
```
## 5. Escolha uma API externa e crie um script para fazer um GET nela mostrando o resultado com HTML.
```js
'use strict';
const http = require('http');
http.get({
hostname: 'webschool-io.herokuapp.com',
path: '/',
port: 80,
agent: false
}, (response) => {
let body = '';
console.log('STATUS: ' + response.status);
console.log('HEADERS: ' + JSON.stringify(response.headers));
response.on('data', (data) => {
body += data;
});
response.on('end', () => {
console.log('Resposta: ', body);
});
});
```
```js
STATUS: 200
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","content-type":"text/html; charset=utf-8","content-length":"374","etag":"W/\"176-Pxdvu7DoyL19Fh8vgF9duw\"","date":"Thu, 10 Nov 2016 05:13:40 GMT","via":"1.1 vegur"}
Resposta: <!DOCTYPE html><html><head><title>Api WebSchool</title><link rel="stylesheet" href="/stylesheets/style.css"></head><body><h1>Api WebSchool</h1><p>Welcome to Api WebSchool</p><p>Routes of api api/pokemons</p><ul><li>get api/pokemons</li><li>post api/pokemons</li><li>getOne api/pokemons/:id</li><li>put api/pokemons/:id</li><li>delete api/pokemons/:id</li></ul></body></html>
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# NodeJS - Aula 03 - Exercício
autor: Fábio Calheiros (conta: fabiocalheiros)
# 1. Por que quando requisitamos ao nosso servidor de Query String, `com o Chrome`, ele executa 2 requisições, sendo a última "vazia"?
Isso acontece porque o Chrome envia um pedido de um favicon em cada solicitação.
Como não enviamos um favicon de volta, ele a responde como um objeto vazio {}.
# 2. Qual a `DIFERENÇA` entre o `GET` e o `POST`?
Para diferenciarmos os dois podemos definir nos seguintes tópicos.
- Visibilidade:
Uma requisição GET é enviada como string anexada a URL, enquanto que a requisição POST é encapsulada junto ao corpo da requisição HTTP e não pode ser vista.
- Tamanho:
O GET possui um limite de até 255 caracteres e é cacheavel pelos navegadores, é aconselhavel para utilizar fazendo consultas simples. O POST não possui limites de caracteres.
- Performance:
A requisição GET é relativamente mais rápida, já que ela é mais simples. Na requisição POST há uma perda de tempo no encapsulamento da mensagem.
- Tipos:
O GET é enviado via URL, então nós sabemos que ela só transporta textos. A requisição POST não tem restrições, pode transportar tanto texto, como dados binários.
- Favoritos/Bookmarks:
Por se tratar apenas de uma URL, a requisição GET pode ser armazenada em cache, ou em um sistema de bookmark(favoritos). A mesma coisa não é possível para requisições POST.
- Método HTML Padrão:
GET é o método HTML padrão. Para submeter um formulário HTML usando POST é preciso especificar no atributo “method” o valor “POST”.
- Dados:
As requisições GET são limitadas ao padrão ASCII, enquanto que requisições POST também podem usar o atributo “enctype” com o valor “multipart/form-data”, que faz uso do padrão UCS(Universal Multiple-Octet Coded Character Set).
# 3. Crie um Pokemon na nossa API com o seu nome, depois modifique seu nome pelo seu user do Github, colocando aqui a resposta de cada passo.
```
node http-request-post.js
postData name=F%C3%A1bio%20Calheiros&type=Aluno
Tamanho do Post Data 38
STATUS:201
HEADERS:{"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"83","etag":"W/\"53-41MdFbUfWH/AU0Zi8klaOQ\"","date":"Mon, 28 Dec 2015 18:48:17 GMT","via":"1.1 vegur"}
Dados finalizados: {"__v":0,"name":"Fábio Calheiros","type":"Aluno","_id":"568183f1683c8d1100366f7a"}
```
```
node http-request-put.js
postData name=fabiocalheiros
Tamanho do Post Data 19
STATUS:202
HEADERS:{"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"108","etag":"W/\"6c-JrRFgRg3QEV9v10ruiKLcg\"","date":"Mon, 28 Dec 2015 18:50:35 GMT","via":"1.1 vegur"}
Dados finalizados: {"data":{"ok":1,"nModified":1,"n":1,"lastOp":"6233409023073320961","electionId":"565e25d106dca622271891c4"}}
```
# 4. Depois faça o DELETE, criando o script para tal, colocndo aqui a resposta.
```
node http-request-delete.js
postData name=Fabrones
Tamanho do Post Data 13
STATUS:204
HEADERS:{"server":"Cowboy","content-length":"0","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","date":"Mon, 28 Dec 2015 18:52:49 GMT","via":"1.1 vegur"}
Dados finalizados:
```
# 5. Escolha uma API externa e crie um script para fazer um GET nela mostrando o resultado em HTML.
```
'use strict';
const https = require('https');
const json2html = require('node-json2html');
const options = {
host: 'api.mercadolibre.com',
path: '/users/156622161/'
};
function callback(res){
console.log('STATUS:' + res.statusCode);
console.log('HEADERS:' + JSON.stringify(res.headers));
res.setEncoding('utf8');
let data = '';
res.on('data', (chunk) => {
data += chunk;
});
res.on('end', ()=>{
var transform = {'tag':'div','html':'${nickname} - id: ${id}'};
var html = json2html.transform(data,transform);
console.log(html);
})
}
const req = https.get(options, callback);
req.on('error', (e)=> {
console.log('Erro ao fazer a leitura dos dados: '+e.message+'\n');
});
req.end();
node exercicio03.js
STATUS:200
HEADERS:{"date":"Wed, 30 Dec 2015 19:43:21 GMT","content-type":"application/json;charset=UTF-8","transfer-encoding":"chunked","connection":"close","cache-control":"max-age=60, stale-while-revalidate=30, stale-if-error=120","vary":"Accept,Accept-Encoding","etag":"5faaf5170e91571d521d2a74d47c6162","x-content-type-options":"nosniff","x-request-id":"408c0459-754e-4f30-a2ca-663ec9abb90f","access-control-allow-origin":"*","access-control-allow-headers":"Content-Type","access-control-allow-methods":"PUT, GET, POST, DELETE, OPTIONS","access-control-max-age":"86400","x-xss-protection":"1; mode=block","strict-transport-security":"max-age=15724800"}
<div>HYPERCOMPRAS-ME - id: 156622161</div>
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 03 - Exercício
**user:** [rafaeljourdan](https://github.com/rafaeljourdan)
**autor:** Rafael Jourdan
## Por que quando requisitamos ao nosso servidor de *Query String*, **com o Chrome**, ele executa 2 requisições, sendo a última "*vazia*"?
O chrome sempre envia 2 requisições, a primeira da URL requisitada e a segunda do favicon.ico. No Firefox somente na primeira vez.
## Qual a DIFERENÇA entre o GET e o POST?
* GET: O conteúdo (somente string) é enviado pela URL e tem limitações de tamanho (dependendo de cada agent). Este verbo do protocolo HTTP geralmente é utilizado para requisição de informações, enviando anexado chaves e valores que façam sentido nesta recuperação no bd.
* POST: O conteúdo é anexado ao corpo da requisição, com isso temos liberdade para enviar arquivos binários e uma quantidade maior de informações.
## Crie um Pokemon na nossa API com seu nome, depois modifique seu nome pelo seu User do Github.
#### Criação do pokemon Rafael F A Jourdan
```js
'use strict';
const http = require('http');
const querystring = require('querystring');
const postData = querystring.stringify({
name: 'Rafael F A Jourdan ',
type: 'aluno'
});
const options = {
host: 'webschool-io.herokuapp.com',
path: '/api/pokemons',
method: 'POST',
headers: {
'Content-Type': 'application/x-www-form-urlencoded',
'Content-Length': postData.length
}
};
function callback(res) {
console.log('STATUS: ' + res.statusCode);
console.log('HEADERS: ' + JSON.stringify(res.headers));
let data = '';
res.setEncoding('utf8');
res.on('data', (chunk) => {
data += chunk;
});
res.on('end', () => {
console.log('Dados finalizados: ', data)
})
}
const req = http.request(options, callback);
req.on('error', (e) => {
console.log('ERRO: ' + e.message);
});
req.write(postData);
req.end();
```
##### Retorno
```js
$ node criacao-pokemon-exerc.js
STATUS: 201
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"appl
ication/json; charset=utf-8","content-length":"86","etag":"W/\"56-6S2zD85c/o0v9yG2k0jCmg\"","date":"Tue, 10 Jan 2017 18:16:02 GM
T","via":"1.1 vegur"}
Dados finalizados: {"__v":0,"name":"Rafael F A Jourdan ","type":"aluno","_id":"587524e2c04fe500123ccee5"}
```
##### Atualização do nome
```js
'use strict';
const http = require('http');
const querystring = require('querystring');
const postData = querystring.stringify({
name: 'rafaeljourdan',
type: 'aluno'
});
const options = {
host: 'webschool-io.herokuapp.com',
path: '/api/pokemons/587524e2c04fe500123ccee5',
method: 'PUT',
headers: {
'Content-Type': 'application/x-www-form-urlencoded',
'Content-Length': postData.length
}
};
function callback(res) {
console.log('STATUS: ' + res.statusCode);
console.log('HEADERS: ' + JSON.stringify(res.headers));
let data = '';
res.setEncoding('utf8');
res.on('data', (chunk) => {
data += chunk;
});
res.on('end', () => {
console.log('Dados finalizados: ', data)
})
}
const req = http.request(options, callback);
req.on('error', (e) => {
console.log('ERRO: ' + e.message);
});
req.write(postData);
req.end();
```
//Modificando Pokémon
```html
$ node exerc_update-pokemon
STATUS: 202
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"appl
ication/json; charset=utf-8","content-length":"121","etag":"W/\"79-SymJl/JdkAwTz2Rl6bUJbw\"","date":"Tue, 10 Jan 2017 18:21:21 G
MT","via":"1.1 vegur"}
Dados finalizados: {"data":{"ok":1,"nModified":1,"n":1,"opTime":{"ts":"6374042770788581377","t":1},"electionId":"7fffffff000000
0000000001"}}
```
## **Depois faça o DELETE**, criando o script para tal, colocando aqui a resposta.
```js
'use strict';
const http = require('http');
const querystring = require('querystring');
const postData = querystring.stringify({
name: 'rafaeljourdan'
});
const options = {
host: 'webschool-io.herokuapp.com',
path: '/api/pokemons/5875246dc04fe500123ccee5',
method: 'DELETE',
headers: {
'Content-Type': 'application/x-www-form-urlencoded',
'Content-Length': postData.length
}
};
function callback(res) {
console.log('STATUS: ' + res.statusCode);
console.log('HEADERS: ' + JSON.stringify(res.headers));
let data = '';
res.setEncoding('utf8');
res.on('data', (chunk) => {
data += chunk;
});
res.on('end', () => {
console.log('Dados finalizados: ', data)
})
}
const req = http.request(options, callback);
req.on('error', (e) => {
console.log('ERRO: ' + e.message);
});
req.end();
```
##### Retorno (Não consegui deletar)
```html
$ node exerc_delete_pokemon
STATUS: 499
HEADERS: {"connection":"close","server":"Cowboy","date":"Tue, 10 Jan 2017 18:27:33 GMT","content-length":"506","content-type":"t
ext/html; charset=utf-8","cache-control":"no-cache, no-store"}
```
## Escolha uma **API externa** e crie um script para fazer um GET nela **mostrando o resultado com HTML**.
```js
'use strict';
const http = require('http');
http.get({
hostname: 'pokeapi.co',
path: '/api/v2/pokemon/55/',
port: 80,
agent: false
}, (response) => {
let body = '';
console.log('STATUS: '+ response.statusCode);
console.log('HEADERS: '+ response.headers);
response.on('data', function(data){
body += data;
});
response.on('end', function(){
var nome = JSON.parse(body).forms[0].name;
retornarHtml(nome);
});
});
const retornarHtml = (nome) => {
let html = '<html><head></head><body><h1>Nome do pokemon: '+nome+' </h1></body></html>';
console.log(html);
};
```
```html
$ node exerc_get_api.js
STATUS: 200
HEADERS: [object Object]
<html><head></head><body><h1>Nome do pokemon: golduck </h1></body></html>
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 03 - Exercício
**user:** [hc3](https://github.com/hc3)
**autor:** Eliel das Virgens
**date:** 20/03/2015
##01.Porque quando requisitamos ao nosso servidor de Query String com o chrome ele executa 2 requisições sendo a última vazia?
-no Chrome são feitas duas requisições a outra é pelo favicon.
##02.Qual a diferença entre o get e o post?
-O get requisita algo ao servidor por exemplo podemos fazer uma busca de uma imagem ao servidor
através do método get, o método post por sua vez consegue inserir algo no servidor alterar com uma segurança maior do que o get, por exemplo usando o get para buscar clientes no banco de dados e usamos o post para cadastrar um novo.
##03.Crie um pokemon na nossa API com seu nome depois modifique seu nome pelo seu User do GitHub colocando aqui a resposta de cada passo a passo.
```
hc3@darkSide:~/Bemean/Node$ node cria_pokemon.js
STATUS: 201
HEADERS: {"server":"darkSide","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"79","etag":"W/\"4f-FQst1JWQGV9Isx6b9QMehg\"","date":"Fri, 20 Mar 2016 22:10:40 GMT","via":"1.1 vegur"}
Dados finalizados {"__v":0,"name":"Eliel das Virgens","type":"SmokeMon","_id":"582f8gt12f61701100d72sc1"}
```
```
hc3@darkSide:~/Bemean/Node$ node altera_pokemon.js
STATUS: 201
HEADERS: {"server":"darkSide","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"79","etag":"W/\"4f-FQst1JWQGV9Isx6b9QMehg\"","date":"Fri, 20 Mar 2016 22:10:40 GMT","via":"1.1 vegur"}
Dados finalizados {"data":{"ok":1,"nModified":1,"n":1,"lastOp":"6240448465881530369","electionId":"582f8gt12f61701100d72sc1"}}
```
##04.Depois daça o delete criando o script para tal, colocando aqui a respota.
```
hc3@darkSide:~/Bemean/Node$ node exclui_pokemon.js
STATUS: 204
HEADERS: {"server":"darkSide","content-length":"0","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","date":"Fri, 20 Mar 2016 22:10:40 GMT","via":"1.1 vegur"}
Dados finalizados
```
##05.Escolha uma API externa e crie um script para fazer um get nela mostrando o resultado com HTML
```
STATUS: 200
HEADERS: {"content-type":"text/html","date":"Sun, 18 Jan 2016 19:25:00 GMT","connection":"close","transfer-encoding":"chunked"}
Dados finalizados:
<html><body><h1>Pokemons</h1><ul><li>Pokemon: Bulbassauro</li><li>Pokemon: Charmander</li><li>Pokemon: Squirtle</li><li>Pokemon: Pikachu</li></ul></body></html>
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 03 - Exercício
**user:** [jeffersondanielss](https://github.com/jeffersondanielss)
**autor:** Jefferson Daniel Santos Silva
## Por que quando requisitamos ao nosso servidor de *Query String*, **com o Chrome**, ele executa 2 requisições, sendo a última "*vazia*"?
Por que a cada requisição o chrome pede também um favicon.
## Qual a DIFERENÇA entre o GET e o POST?
O método GET transporta apenas textos até 255 caracteres que podem ser armazenadas em cache, já o POST pode transportar outros tipos de dados, não possui tamanho máximo para envio mas não pode ser armazenado em cache.
## Crie um Pokemon na nossa API com seu nome, depois modifique seu nome pelo seu User do Github.
```
STATUS: 201
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-c
ontrol-allow-origin":"*","content-type":"application/json; charset=utf-8","content-
length":"83","etag":"W/\"53-RXG9NFsfcTshTpw7BRBGLw\"","date":"Sun, 13 Mar 2016 19:1
4:48 GMT","via":"1.1 vegur"}
Dados finalizados: {"__v":0,"name":"Jefferson Daniel","type":"Aluno","_id":"56e5bc
2733a78b1100c06ebb"}
```
```
STATUS: 202
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-c
ontrol-allow-origin":"*","content-type":"application/json; charset=utf-8","content-
length":"108","etag":"W/\"6c-zxp2AvRAjB/3nkyyVhKR6A\"","date":"Sun, 13 Mar 2016 19:
37:31 GMT","via":"1.1 vegur"}
Dados finalizados: {"data":{"ok":1,"nModified":1,"n":1,"lastOp":"62616235909536808
97","electionId":"565e25d106dca622271891c4"}}
```
## **Depois faça o DELETE**, criando o script para tal, colocando aqui a resposta.
```
'use strict';
const http = require('http');
const querystring = require('querystring');
const options = {
host: 'webschool-io.herokuapp.com'
, method: 'DELETE'
, path: '/api/pokemons/56e5bc2733a78b1100c06ebb'
};
function callback(res) {
console.log('STATUS: ' + res.statusCode);
console.log('HEADERS: ' + JSON.stringify(res.headers));
let data = '';
res.setEncoding('utf8');
res.on('data', (chunk) => {
data += chunk;
});
res.on('end', () => {
console.log('Dados finalizados: ', data)
})
}
const req = http.request(options, callback);
req.on('error', (e) => {
console.log('ERROOOO: ' + e.message);
});
req.end();
STATUS: 204
HEADERS: {"server":"Cowboy","content-length":"0","connection":"close","x-powered-by
":"Express","access-control-allow-origin":"*","date":"Sun, 13 Mar 2016 19:51:58 GMT
","via":"1.1 vegur"}
Dados finalizados:
```
## Escolha uma **API externa** e crie um script para fazer um GET nela **mostrando o resultado com HTML**.
```
'use strict';
const http = require('http');
var result = '';
http.get({
hostname: 'webschool-io.herokuapp.com'
,path: '/api/pokemons'
,port:80
,agent: false
}, ( response )=>{
console.log('STATUS: '+response.statusCode);
console.log('HEADERS: '+JSON.stringify(response.headers));
response.on('data', function( data ){
result += data;
});
response.on('end', function(){
newServer();
});
});
function newServer(){
http.createServer(function(request, response){
var pokemons = JSON.parse( result );
for(var key in pokemons){
var pokemon = pokemons[key];
response.write('<b>ID:</b> '+pokemon._id+' <b>Nome:</b> '+pokemon.name+' <b>Tipo:</b> '+pokemon.type+'<br>');
}
response.end();
}).listen(3000, function(){
console.log('Porta: 3000');
});
}
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 03 - Exercício
**user:** [ajoao88](https://github.com/ajoao88)<br>**autor:** João Paulo S de Araújo<br>**date:** 1454957716069
## 1. Por que quando requisitamos ao nosso servidor de Q!uery String, **com o Chrome**, ele executa 2 requisições, sendp a última "vazia"?
Porque atumaticamente ele faz uma segunda requisição solicitando o "favicon.ico", esse favicon hoje é usado para melhor identificação da página, fica à esquena do title na aba do navegador.
## 2. Qual a DIFERENÇA entre o GET e o POST?
|Característica | GET | POST|
|------------------------------ | -------------------------------------------------------------------------------- |-----|
|**Limite bytes** | 1024 bytes. | Não possui.|
|**Padrão de transmissão** | URL (Uniform Resource Locator). | URI (Uniform Resource Indentifier).|
|**Como lida com os dados** | Expôe os dados na barra de endereços e eles ficam em cache (histórico). | Encapsula os dados no corpo da requisição HTTP (Hyper Text Transfer Protocol), nenhum dado é visivel ao cliente e nem fica em cache.|
|**Formato dos dados enviados** | Query String | Query String|
|**Indicações** | Envio de poucas e pequenas informações que não necessitam de segurançaou sigilo. | Envio de bastante e/ou grandes informações ou que necessitem de segurança e sigilo.|
## 3. Crie um Pokemon na nossa API com seu nome, depois modifique seu nome pelo seu User do Github, colocando aqui a resposta de cada passo.
### Criação:
> **postData:** name=Jo%C3%A3o%20Paulo&type=Estudante<br>**Tamanho do postData:** 37<br>**STATUS:** 201<br>**HEADERS:**
> ```json
> {
> "server":"Cowboy",
> "connection":"close",
> "x-powered-by":"Express",
> "access-control-allow-origin":"*",
> "content-type":"application/json;charset=utf-8",
> "content-length":"82",
> "etag":"W/"52-vko+eX5L8Ez2Vut24AhcMg"",
> "date":"Mon, 08 Feb 2016 19:54:04 GMT",
> "via":"1.1 vegur"
> }
> ```
> **Dados finalizados:**
> ```json
> {
> "__v":0,
> "name":"João Paulo",
> "type":"Estudante",
> "_id":"56b8f25cde84f01100aba215"
> }
> ```
### Atualização
> **postData:** name=ajoao88<br>**Tamanho do postData:** 12<br>**STATUS:** 202<br>**HEADERS:**
> ```json
> {
> "server":"Cowboy",
> "connection":"close",
> "x-powered-by":"Express",
> "access-control-allow-origin":"*",
> "content-type":"application/json; charset=utf-8",
> "content-length":"108",
> "etag":"W/"6c-XhSV7vAGvhRKZPCPduEgRQ"",
> "date":"Mon, 08 Feb 2016 20:04:52 GMT","via":"1.1 vegur"
> }
> ```
> **Dados finalizados:**
> ```json
> {
> "data":
> {
> "ok":1,
> "nModified":1,
> "n":1,
> "lastOp":"6249013743066284033",
> "electionId":
> "565e25d106dca622271891c4"
> }
> }
> ```
## 4. **Depois faça o DELETE**, criando o script para tal, colocando aqui a resposta.
> postData:''<br>Tamanho do postData: 0<br>STATUS: 204<br>HEADERS:
> ```json
> {
> "server":"Cowboy",
> "content-length":"0",
> "connection":"close",
> "x-powered-by":"Express",
> "access-control-allow-origin":"*",
> "date":"Mon, 08 Feb 2016 20:22:42 GMT",
> "via":"1.1 vegur"
> }
> ```
> Dados finalizados: ''
## 5. Escolha uma **API externa** e crie um script para fazer um GET nela **mostrando o resultado com HTML**.
#### [Api Mercado Libre](https://api.mercadolibre.com)
```js
'use strict'
const https = require('https'),
options = {
host: 'api.mercadolibre.com',
path: '/sites/'
},
json2Html = require('node-json2html')
function callback(res) {
console.log('STATUS: ' + res.statusCode);
console.log('HEADERS: ' + JSON.stringify(res.headers));
let body = '';
res.setEncoding('utf-8');
res.on('data',(chunk) => {
body += chunk;
});
res.on('end', () => {
var transform = {
"tag": "li","id": "${id}","html": "${name}"
};
var html = "<ul>"
html += json2Html.transform(body,transform);
html += "</ul>"
console.log('Dados em JSON: ', body);
console.log('Dados em HTML: ',html);
});
}
const req = https.request(options,callback);
req.on('error', (e) => {
console.log('Erro: ' + e.message);
});
req.end();
```
Dados em JSON:
```json
[
{"id":"MLA","name":"Argentina"},
{"id":"MBO","name":"Bolivia"},
{"id":"MLB","name":"Brasil"},
{"id":"MLC","name":"Chile"},
{"id":"MCO","name":"Colombia"},
{"id":"MCR","name":"Costa Rica"},
{"id":"MRD","name":"Dominicana"},
{"id":"MEC","name":"Ecuador"},
{"id":"MGT","name":"Guatemala"},
{"id":"MLM","name":"Mexico"},
{"id":"MPY","name":"Paraguay"},
{"id":"MPA","name":"Panamá"},
{"id":"MPE","name":"Perú"},
{"id":"MPT","name":"Portugal"},
{"id":"MLU","name":"Uruguay"},
{"id":"MLV","name":"Venezuela"}
]
```
Dados em HTML:
```html
<ul>
<li id="MLA">Argentina</li>
<li id="MBO">Bolivia</li>
<li id="MLB">Brasil</li>
<li id="MLC">Chile</li>
<li id="MCO">Colombia</li>
<li id="MCR">Costa Rica</li>
<li id="MRD">Dominicana</li>
<li id="MEC">Ecuador</li>
<li id="MGT">Guatemala</li>
<li id="MLM">Mexico</li>
<li id="MPY">Paraguay</li>
<li id="MPA">Pana má</li>
<li id="MPE">Perú</li>
<li id="MPT">Portugal</li>
<li id="MLU">Uruguay</li>
<li id="MLV">Venezuela</li>
</ul>
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 03 - Exercício
**User:** [Geriel Castro](https://github.com/geriel)
**Autor:** Geriel Castro
## Por que quando requisitamos ao nosso servidor de *Query String*, **com o Chrome**, ele executa 2 requisições, sendo a última "*vazia*"?
Isso ocorre apenas no Chrome, na primeira requisição ele obtem os dados normalmente, na segunda requisição é solicitado o `favicon` do servidor
## Qual a DIFERENÇA entre o GET e o POST?
* **GET**
- As informações são enviadas como String na URL
- Tamanho limitado de capacidade de envio
- Mais rápido já que é mais simples
- Envia somente String
- Informações enviadas ficam ficam armazenadas no cache
* **POST**
- As informações são encapsuladas junto ao corpo da requisição HTTP
- Sem limitação de comprimento
- As informações não ficam gravadas em cache
- Por conta do encapsulamento gera uma demora no envio
- Envia qualquer tipo de dados
## Crie um Pokemon na nossa API com seu nome, depois modifique seu nome pelo seu User do Github.
```js
STATUS: 201
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"80","etag":"W/\"50-hf+ZFF9yxZcHPPp5dfTIeg\"","date":"Mon, 28 Mar 2016 05:36:55 GMT","via":"1.1 vegur"}
Dados finalizados: {"__v":0,"name":"Geriel","type":"Aluno","_id":"56f8c2f790983f110020cabe"}
```
---
```js
STATUS: 202
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"108","etag":"W/\"6c-tMnyX/9VLwyzxeDMUlkj3A\"","date":"Mon, 28 Mar 2016 05:39:16 GMT","via":"1.1 vegur"}
Dados finalizados: {"data":{"ok":1,"nModified":1,"n":1,"lastOp":"6266973853189144577","electionId":"56ee12f2563048036a1e77e7"}}
```
## **Depois faça o DELETE**, criando o script para tal, colocando aqui a resposta.
```js
STATUS: 204
HEADERS: {"server":"Cowboy","content-length":"0","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","date":"Mon, 28 Mar 2016 05:41:35 GMT","via":"1.1 vegur"}
Dados finalizados:
```
## Escolha uma **API externa** e crie um script para fazer um GET nela **mostrando o resultado com HTML**.
```html
STATUS: 200
HEADERS: {"date":"Mon, 28 Mar 2016 06:18:44 GMT","content-type":"application/json","content-length":"319","connection":"close","set-cookie":["__cfduid=d4d2fb3ef3de7ad617f9b2ff7fd1feb321459145924; expires=Tue, 28-Mar-17 06:18:44 GMT; path=/; domain=.postmon.com.br; HttpOnly"],"access-control-allow-origin":"*","cache-control":"public, max-age=2592000","x-cache-status":"MISS","cf-cache-status":"HIT","expires":"Wed, 27 Apr 2016 06:18:44 GMT","server":"cloudflare-nginx","cf-ray":"28a8f76b9b8123ae-IAD"}
<html>
<body>
<h1> RESULT: </h1>
<pre>
{
"complemento": "de 146 ao fim - lado par",
"bairro": "Centro",
"cidade": "Rio de Janeiro",
"logradouro": "Avenida Rio Branco",
"estado_info": {
"area_km2": "43.777,954",
"codigo_ibge": "33",
"nome": "Rio de Janeiro"
},
"cep": "20040003",
"cidade_info": {
"area_km2": "1200,278",
"codigo_ibge": "3304557"
},
"estado": "RJ"
}
</pre>
</body>
</html>
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 03 - Exercício
**user:** [fernandobd42](https://github.com/fernandobd42/)
**autor:** Fernando Lucas
## Por que quando requisitamos ao nosso servidor de *Query String*, **com o Chrome**, ele executa 2 requisições, sendo a última "*vazia*"?
Porque além da requisição explícita, ela faz uma requisição implícita para buscar o favicon
## Qual a DIFERENÇA entre o GET e o POST?
* **GET:** É o método de leitura, que passa informações como parâmetros pela URL, aceita só String e tem tamanho limitado.
* **POST:** É o método de inserção, suas informações são incapsuladas no HTTP, aceitar qualquer tipo de dado, e não tem limite de tamanho.
## Crie um Pokemon na nossa API com seu nome, depois modifique seu nome pelo seu User do Github.
## CRIANDO - POST
```
const http = require('http');
const querystring = require('querystring');
const postData = querystring.stringify({
name: 'Fernando'
, type: 'Estudante/Desenvolvedor'
});
console.log('Tamanho:', postData);
console.log('Tamanho do postData: ', postData.length);
const options = {
host: 'webschool-io.herokuapp.com'
, method: 'POST'
, path: '/api/pokemons'
, headers: {
'Content-Type' : 'application/x-www-form-urlencoded'
, 'Content-Length' : postData.length
}
};
function callback(res) {
console.log('STATUS: ' + res.statusCode);
console.log('HEADERS: ' + JSON.stringify(res.headers));
let data = '';
res.setEncoding('utf8');
res.on('data', (chunk) => {
data += chunk;
});
res.on('end', () => {
console.log('Dados finalizados: ', data)
})
}
const req = http.request(options, callback);
req.on('erro', (e) => {
console.log('EROOOO: ' + e.message);
});
req.write(postData);
req.end();
```
#### SAíDA
```
Tamanho: name=Fernando&type=Estudante%2FDesenvolvedor
Tamanho do postData: 44
STATUS: 201
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"93","etag":"W/\"5d-LFekuOlLnoKhZ+3ogin1sg\"","date":"Sat, 12 Nov 2016 17:21:35 GMT","via":"1.1 vegur"}
Dados finalizados: {"__v":0,"name":"Fernando","type":"Estudante/Desenvolvedor","_id":"58274f9f771fcc0012ecc28b"}
```
## MODIFICANDO - PUT
```
const http = require('http');
const querystring = require('querystring');
const postData = querystring.stringify({
name: 'fernandobd42'
, type: 'Estudante/Desenvolvedor'
});
const options = {
host: 'webschool-io.herokuapp.com'
, method: 'PUT'
, path: '/api/pokemons/58274f9f771fcc0012ecc28b'
, headers: {
'Content-Type' : 'application/x-www-form-urlencoded'
, 'Content-Length' : postData.length
}
};
function callback(res) {
console.log('STATUS: ' + res.statusCode);
console.log('HEADERS: ' + JSON.stringify(res.headers));
let data = '';
res.setEncoding('utf8');
res.on('data', (chunk) => {
data += chunk;
});
res.on('end', () => {
console.log('Dados finalizados: ', data)
})
}
const req = http.request(options, callback);
req.on('erro', (e) => {
console.log('EROOOO: ' + e.message);
});
req.write(postData);
req.end();
```
#### SAíDA
```
STATUS: 202
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"121","etag":"W/\"79-okD1ZBdyVqHfX5H6W/u62A\"","date":"Sat, 12 Nov 2016 17:24:31 GMT","via":"1.1 vegur"}
Dados finalizados: {"data":{"ok":1,"nModified":1,"n":1,"opTime":{"ts":"6352134099662012417","t":0},"electionId":"7fffffff0000000000000000"}}
```
## **Depois faça o DELETE**, criando o script para tal, colocando aqui a resposta.
```
const http = require('http');
const querystring = require('querystring');
const postData = querystring.stringify({
name: 'Fernando'
, type: 'Estudante/Desenvolvedor'
});
const options = {
host: 'webschool-io.herokuapp.com'
, method: 'DELETE'
, path: '/api/pokemons/58274f9f771fcc0012ecc28b'
, headers: {
'Content-Type' : 'application/x-www-form-urlencoded'
, 'Content-Length' : postData.length
}
};
function callback(res) {
console.log('STATUS: ' + res.statusCode);
console.log('HEADERS: ' + JSON.stringify(res.headers));
let data = '';
res.setEncoding('utf8');
res.on('data', (chunk) => {
data += chunk;
});
res.on('end', () => {
console.log('Dados finalizados: ', data)
})
}
const req = http.request(options, callback);
req.on('erro', (e) => {
console.log('EROOOO: ' + e.message);
});
req.write(postData);
req.end();
```
#### SAÍDA
```
STATUS: 204
HEADERS: {"server":"Cowboy","content-length":"0","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","date":"Sat, 12 Nov 2016 17:25:40 GMT","via":"1.1 vegur"}
Dados finalizados:
```
## Escolha uma **API externa** e crie um script para fazer um GET nela **mostrando o resultado com HTML**.
```
const http = require('http');
const options = {
host: 'api.redtube.com'
, path: '/?data=redtube.Videos.searchVideos&search=girlfriend'
};
function callback(res) {
console.log('STATUS: '+ res.statusCode);
console.log('HEADERS: '+ JSON.stringify(res.headers));
let data = '';
res.setEncoding('utf8');
res.on('data', (chunk) => {
data += chunk;
});
res.on('end', () => {
var result = JSON.parse(data);
console.log('<html><head><title>Exercicio 3</title></head>');
console.log('<body><div>');
console.log(result.videos[0].video);
console.log('</div></body></html>');
})
}
const req = http.request(options, callback);
req.on('error', (e) => {
console.log('ERROOOOO: ' + e.message)
});
req.end();
```
#### SAÍDA
```
STATUS: 200
HEADERS: {"server":"nginx","date":"Sat, 12 Nov 2016 18:29:19 GMT","content-type":"application/json;charset=utf-8","transfer-encoding":"chunked","connection":"close","set-cookie":["PHPSESSID=u9h2tiu22btr5ehp15hv4he3t2; path=/","RNLBSERVERID=ded6287; path=/"],"expires":"Thu, 19 Nov 1981 08:52:00 GMT","cache-control":"no-store, no-cache, must-revalidate, post-check=0, pre-check=0","pragma":"no-cache"}
<html><head><title>Exercicio 3</title></head>
<body><div>
{ duration: '6:04',
views: '0',
video_id: '1806447',
rating: '3.00',
ratings: '2',
title: 'Lucy Levon takes some dick from a geek',
url: 'http://www.redtube.com/1806447',
embed_url: 'http://embed.redtube.com/?id=1806447',
default_thumb: '//thumbs-cdn.redtube.com/m=e0YH8f/media/videos/0001806/1806447/thumbs/1806447_015o.jpg',
thumb: '//thumbs-cdn.redtube.com/m=e0YH8f/media/videos/0001806/1806447/thumbs/1806447_015o.jpg',
publish_date: '2016-11-12 18:34:31',
tags:
[ { tag_name: 'Amateur' },
{ tag_name: 'Asian' },
{ tag_name: 'Blowjob' },
{ tag_name: 'Couple' },
{ tag_name: 'HD' },
{ tag_name: 'MILF' },
{ tag_name: 'Oral Sex' },
{ tag_name: 'Vaginal Sex' } ] }
</div></body></html>
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 03 - Exercício
**user:** [fauker](https://github.com/fauker)
**autor:** LUCAS DA SILVA MOREIRA
## Por que quando requisitamos ao nosso servidor de *Query String*, **com o Chrome**, ele executa 2 requisições, sendo a última "*vazia*"?
A requisição adicional é feita porque o **Chrome** está tentando buscar
o `favicon.ico` da aplicação.
## Qual a DIFERENÇA entre o GET e o POST?
De uma forma bem simples: `GET` é utilizado para requisitar dados sem
alterá-los no servidor, enquanto `POST` é utilizado para inserir algo no
servidor. Por exemplo: uma página de pesquisa deve utilizar `GET`,
enquanto um formulário de cadastro deve utilizar `POST` para submeter as
informações ao servidor.
Comparação:
**Histórico**:
- GET: Os parâmetros são salvos no browser porque eles fazem parte da
URL.
- POST: Os parâmetros não são salvos no browser.
**Favoritos no navegador**:
- GET: Pode ser adicionado em favoritos, no navegador.
- POST: Não pode ser adicionado em favoritos, no navegador.
**Tipos de dados suportados**:
- GET: application/x-www-form-urlencoded
- POST: multipart/form-data ou application/x-www-form-urlencoded
**Cache**:
- GET: Pode ser cacheado
- POST: Não pode ser cacheado
**Restrições no formato dos dados**:
- GET: Apenas caracteres ASCII são permitidos
- POST: Sem restrições. Arquivos binátios também são permitidos.
**Usabilidade/Visibilidade**:
- GET: Todas as informações são visíveis na URL, portanto não é
recomendado utilizar este método para enviar informações delicadas,
senhas etc.
- POST: As informações são enviadas junto com a requisição HTTP,
portando nada fica visível na URL. Sendo assim, este método é o
recomendado para o envio de informações delicadas/senhas para o
servidor.
## Crie um Pokemon na nossa API com seu nome, depois modifique seu nome pelo seu User do Github.
**POST**
```
'use strict';
const http = require('http');
const querystring = require('querystring');
const postData = querystring.stringify({
name: 'Lucas Moreira'
, type: 'student'
});
console.log("postData", postData);
console.log("Tamanho do postData", postData.length);
const options = {
host: 'webschool-io.herokuapp.com'
, method: 'POST'
, path: '/api/pokemons'
, headers: {
'Content-Type': 'application/x-www-form-urlencoded'
, 'Content-Length': postData.length
}
};
function callback(res) {
console.log('STATUS: ' + res.statusCode);
console.log('HEADERS: ' + JSON.stringify(res.headers));
let data = '';
res.setEncoding('utf8');
res.on('data', (chunk) => {
data += chunk;
});
res.on('end', () => {
console.log('Dados finalizados: ', data)
})
}
const req = http.request(options, callback);
req.on('error', (e) => {
console.log('ERROOOO: ' + e.message);
});
req.write(postData);
req.end();
```
**Resposta**:
```
postData name=Lucas%20Moreira&type=student
Tamanho do postData 33
STATUS: 201
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"82","etag":"W/\"52-aF+iYI+9imnEnoNvlnzrzQ\"","date":"Thu, 21 Apr 2016 13:05:28 GMT","via":"1.1 vegur"}
Dados finalizados: {"__v":0,"name":"Lucas Moreira","type":"student","_id":"5718d018cdd40a1100cf59a1"}
```
**PUT**
```
'use strict';
const http = require('http');
const querystring = require('querystring');
const postData = querystring.stringify({
name: 'fauker'
});
const options = {
host: 'webschool-io.herokuapp.com'
, method: 'PUT'
, path: '/api/pokemons/5718d018cdd40a1100cf59a1'
, headers: {
'Content-Type': 'application/x-www-form-urlencoded'
, 'Content-Length': postData.length
}
};
function callback(res) {
console.log('STATUS: ' + res.statusCode);
console.log('HEADERS: ' + JSON.stringify(res.headers));
let data = '';
res.setEncoding('utf8');
res.on('data', (chunk) => {
data += chunk;
});
res.on('end', () => {
console.log('Dados finalizados: ', data)
})
}
const req = http.request(options, callback);
req.on('error', (e) => {
console.log('ERROOOO: ' + e.message);
});
req.write(postData);
req.end();
```
**Resposta:**
```
STATUS: 202
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"108","etag":"W/\"6c-MWWv9jU4vqlcL2ixcMLOUQ\"","date":"Thu, 21 Apr 2016 13:12:31 GMT","via":"1.1 vegur"}
```
## **Depois faça o DELETE**, criando o script para tal, colocando aqui a resposta.
**DELETE**
```
'use strict';
const http = require('http');
const querystring = require('querystring');
const options = {
host: 'webschool-io.herokuapp.com'
, method: 'delete'
, path: '/api/pokemons/5718d018cdd40a1100cf59a1'
, headers: {
'content-type': 'application/x-www-form-urlencoded'
}
};
function callback(res) {
console.log('status: ' + res.statuscode);
console.log('headers: ' + json.stringify(res.headers));
let data = '';
res.setencoding('utf8');
res.on('data', (chunk) => {
data += chunk;
});
res.on('end', () => {
console.log('dados finalizados: ', data)
})
}
const req = http.request(options, callback);
req.on('error', (e) => {
console.log('erroooo: ' + e.message);
});
req.end();
```
***Resposta***
```
STATUS: 204
HEADERS: {"server":"Cowboy","content-length":"0","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","date":"Thu, 21 Apr 2016 13:16:17 GMT","via":"1.1 vegur"}
```
## Escolha uma **API externa** e crie um script para fazer um GET nela **mostrando o resultado com HTML**.
```
'use strict';
const http = require('http');
const options = {
host: 'api.redtube.com'
, path: '/?data=redtube.Videos.searchVideos&search=Sasha%20Gray'
};
function callback(res) {
console.log('STATUS: ' + res.statusCode);
console.log('HEADERS: ' + JSON.stringify(res.headers));
let data = [];
res.setEncoding('utf8');
res.on('data', (chunk) => {
data += chunk;
});
res.on('end', () => {
var json = JSON.parse(data);
console.log('<html>');
console.log('<head></head>');
console.log('<body>');
console.log('<div>');
console.log(json.videos[0].video);
console.log('</div>');
console.log('</body>');
console.log('</html>');
})
}
const req = http.request(options, callback);
req.on('error', (e) => {
console.log('ERROOOO: ' + e.message);
});
req.end();
```
```
STATUS: 200
HEADERS: {"server":"nginx","date":"Thu, 21 Apr 2016 13:41:52 GMT","content-type":"application/json;charset=utf-8","transfer-encoding":"chunked","connection":"close","set-cookie":["PHPSESSID=8ta1697inn11p57ponibo5g705; path=/","RNLBSERVERID=ded6281; path=/"],"expires":"Thu, 19 Nov 1981 08:52:00 GMT","cache-control":"no-store, no-cache, must-revalidate, post-check=0, pre-check=0","pragma":"no-cache"}
<html>
<head></head>
<body>
<div>
{ duration: '11:24',
views: '574759',
video_id: '302038',
rating: '3.87',
ratings: '450',
title: 'Sasha Grey at Anatomie HD',
url: 'http://www.redtube.com/302038',
embed_url: 'http://embed.redtube.com/?id=302038',
default_thumb: 'http://img.l3.cdn.redtubefiles.com/_thumbs/0000302/0302038/0302038_012m.jpg',
thumb: 'http://img.l3.cdn.redtubefiles.com/_thumbs/0000302/0302038/0302038_012m.jpg',
publish_date: '2016-04-20 10:50:01',
tags:
[ { tag_name: 'Anal Sex' },
{ tag_name: 'Brunette' },
{ tag_name: 'Caucasian' },
{ tag_name: 'Couple' },
{ tag_name: 'Hairy' },
{ tag_name: 'Pornstar' },
{ tag_name: 'Uniform' } ],
stars: [ { star_name: 'Sasha Grey' } ] }
</div>
</body>
</html>
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# NodeJS - Aula 01 - Exercício
**Autor**: Igor luíz
**Github**: [Halfeld](https://github.com/Halfeld)
**Data**: 1457214015206
# Por que quando requisitamos ao nosso servidor de Query String, com o Chrome, ele executa 2 requisições, sendo a última "vazia"?
Pois em cada requisição, o Chrome também faz a solicitação de um _favicon_.
# Qual a diferença entre o GET e o POST?
Os dois são usados para fazer requisições no servidor, com a principal diferença entre os dois, o `GET` passa os parametros pela url, já o `POST` manda os parametros encapsuladod junto ao corpo da requisição.
As requisições do tipo `GET` são mais para leitura, e as do tipo `POST` são usadas para fazer alterações.
# Crie um Pokemon na nossa API com seu nome, depois modifique seu nome pelo seu User do Github, colocando aqui a resposta de cada passo.
### Cadastrando com o meu nome
```js
'use strict';
const http = require('http'),
querystring = require('querystring');
const postData = querystring.stringify({
name: 'Igor Luíz',
type: 'Student'
});
const options = {
host: 'webschool-io.herokuapp.com',
method: 'POST',
path: '/api/pokemons',
headers: {
'Content-Type' : 'application/x-www-form-urlencoded',
'Contetn-length': postData.length
}
}
function callback(res) {
let data = '';
res.setEncoding('utf8');
res.on('data', chunk => {
data += chunk;
});
res.on('end', () => {
console.log(`Efetuado cadastro: ${data}`);
});
}
const req = http.request(options, callback);
req.write(postData);
req.end();
```
### Saída no terminal
```js
➜ class-3 git:(master) ✗ node create-pokemon.js
Efetuado cadastro: {"__v":0,"name":"Igor Luíz","type":"Student","_id":"56db4f19204b6b1100a5212e"}
```
### Modificando com o meu user do github
```js
'use strict';
const http = require('http'),
querystring = require('querystring');
const postData = querystring.stringify({
name: 'Halfeld',
type: 'Student'
});
const options = {
host: 'webschool-io.herokuapp.com',
method: 'PUT',
path: '/api/pokemons/56db4f19204b6b1100a5212e',
headers: {
'Content-Type' : 'application/x-www-form-urlencoded',
'Contetn-length': postData.length
}
}
function callback(res) {
let data = '';
res.setEncoding('utf8');
res.on('data', chunk => {
data += chunk;
});
res.on('end', () => {
console.log(`Atualizado cadastro: ${data}`);
});
}
const req = http.request(options, callback);
req.write(postData);
req.end();
```
### Saída no terminal
```js
➜ class-3 git:(master) ✗ node update-pokemon.js
Efetuado cadastro: {"data":{"ok":1,"nModified":1,"n":1,"lastOp":"6258683737379176449","electionId":"565e25d106dca622271891c4"}}
```
# Depois faça o delete, criando o script para tal, colocando aqui a resposta.
```js
'use strict';
const http = require('http'),
querystring = require('querystring');
const postData = querystring.stringify({
name: 'Halfeld',
type: 'Student'
});
const options = {
host: 'webschool-io.herokuapp.com',
method: 'DELETE',
path: '/api/pokemons/56db4f19204b6b1100a5212e',
headers: {
'Content-Type' : 'application/x-www-form-urlencoded',
'Contetn-length': postData.length
}
}
function callback(res) {
res.setEncoding('utf8');
res.on('end', () => {
console.log('Cadastro removido');
});
}
const req = http.request(options, callback);
req.write(postData);
req.end();
```
# Escolha uma API externa e crie um script para fazer um GET nela mostrando o resultado em HTML.
### Código
```js
'use strict';
const http = require('http');
const options = {
host: 'pokeapi.co',
method: "GET",
path: '/api/v1/pokemon/',
headers: {
'Content-Type': 'application/json'
}
};
function callback(res) {
res.setEncoding('utf8');
res.on('data', chunck => {
console.log(chunck);
});
res.on('end', () => {
console.log('Finalizado');
});
}
const req = http.request(options, callback);
req.end();
```
### Saída
```js
➜ class-3 git:(master) ✗ node api-pokemon-request.js
{"meta": {"limit": 1, "next": "/api/v1/pokemon/?limit=1&offset=1", "offset": 0, "previous": null, "total_count": 778}, "objects": [{"abilities": [{"name": "run-away", "resource_uri": "/api/v1/ability/50/"}, {"name": "hustle", "resource_uri": "/api/v1/ability/55/"}, {"name": "guts", "resource_uri": "/api/v1/ability/62/"}], "attack": 56, "catch_rate": 0, "created": "2013-11-03T15:05:41.305777", "defense": 35, "descriptions": [{"name": "rattata_gen_1", "resource_uri": "/api/v1/description/290/"}, {"name": "rattata_gen_1", "resource_uri": "/api/v1/description/291/"}, {"name": "rattata_gen_1", "resource_uri": "/api/v1/description/292/"}, {"name": "rattata_gen_1", "resource_uri": "/api/v1/description/288/"}, {"name": "rattata_gen_1", "resource_uri": "/api/v1/description/289/"}, {"name": "rattata_gen_2", "resource_uri": "/api/v1/description/293/"}, {"name": "rattata_gen_2", "resource_uri": "/api/v1/description/294/"}, {"name": "rattata_gen_3", "resource_uri": "/api/v1/description/295/"}, {"name": "rattata_gen_3", "resource_uri": "/api/v1/description/296/"}, {"name": "rattata_gen_4", "resource_uri": "/api/v1/description/300/"}, {"name": "rattata_gen_3", "resource_uri": "/api/v1/des
cription/297/"}, {"name": "rattata_gen_4", "resource_uri": "/api/v1/description/298/"}, {"name": "rattata_gen_4", "resource_uri": "/api/v1/description/299/"}, {"name": "rattata_gen_5", "resource_uri": "/api/v1/description/301/"}], "egg_cycles": 0, "egg_groups": [{"name": "Ground", "resource_uri": "/api/v1/egg/5/"}], "ev_yield": "", "evolutions": [{"level": 20, "method": "level_up", "resource_uri": "/api/v1/pokemon/20/", "to": "Raticate"}], "exp": 51, "growth_rate": "", "happiness": 0, "height": "3", "hp": 30, "male_female_ratio": "", "modified": "2013-11-23T13:13:24.187255", "moves": [{"learn_type": "tutor", "name": "Covet", "resource_uri": "/api/v1/move/343/"}, {"learn_type": "machine", "name": "Wild-charge", "resource_uri": "/api/v1/move/528/"}, {"learn_type": "machine", "name": "Work-up", "resource_uri": "/api/v1/move/526/"}, {"learn_type": "egg move", "name": "Final-gambit", "resource_uri": "/api/v1/move/515/"}, {"learn_type": "machine", "name": "Retaliate", "resource_uri": "/api/v1/move/514/"}, {"learn_type": "machine", "name": "Round", "resource_uri": "/api/v1/move/496/"}, {"learn_type": "egg move", "name": "Revenge", "resource_uri": "/api/v1/move/279/"}, {"learn_type": "tutor", "name": "Zen-headbutt", "resource_uri": "/api/v1/move/428/"}, {"learn_type": "machine", "name": "Charge-beam", "resource_uri": "/api/v1/move/451/"}, {"learn_type": "machine", "name": "Grass-knot", "resource_uri": "/api/v1/move/447/"}, {"learn_type": "machine", "name": "Captivate", "resource_uri": "/api/v1/move/445/"}, {"learn_type": "level up", "level": 19, "name": "Sucker-punch", "resource_uri": "/api/v1/move/389/"}, {"learn_type": "egg move", "name": "Last-resort", "resource_uri": "/api/v1/move/387/"}, {"learn_type": "egg move", "name": "Me-first", "resource_uri": "/api/v1/move/382/"}, {"learn_type": "level up", "level": 25, "name": "Assurance", "resource_uri": "/api/v1/move/372/"}, {"learn_type": "machine", "name": "U-turn", "resource_uri": "/api/v1/move/369/"}, {"learn_type": "machine", "name": "Pluck", "resource_uri": "/api/v1/move/365/"}, {"learn_type": "machine", "name": "Natural-gift", "resource_uri": "/api/v1/move/363/"}, {"learn_type": "level up", "level": 22, "name": "Crunch", "resource_uri": "/api/v1/move/242/"}, {"learn_type": "tutor", "name": "Thunder-wave", "resource_uri": "/api/v1/move/86/"}, {"learn_type": "machine", "name": "Shock-wave", "resource_uri": "/api/v1/move/351/"}, {"learn_type": "machine", "name": "Secret-power", "resource_uri": "/api/v1/move/290/"}, {"learn_type": "level up", "level": 41, "name": "Endeavor", "resource_uri": "/api/v1/move/283/"}, {"learn_type": "machine", "name": "Taunt", "resource_uri": "/api/v1/move/269/"}, {"learn_type": "machine", "name": "Facade", "resource_uri": "/api/v1/move/263/"}, {"learn_type": "egg move", "name": "Uproar", "resource_uri": "/api/v1/move/253/"}, {"learn_type": "machine", "name": "Rain-dance", "resource_uri": "/api/v1/move/240/"}, {"learn_type": "machine", "name": "Ice-beam", "resource_uri": "/api/v1/move/58/"}, {"learn_type": "machine", "name": "Cut", "resource_uri": "/api/v1/move/15/"}, {"learn_type": "machine", "name": "Rock-smash", "resource_uri": "/api/v1/move/249/"}, {"learn_type": "machine", "name": "Shadow-ball", "resource_uri": "/api/v1/move/247/"}, {"learn_type": "machine", "name": "Sunny-day", "resource_uri": "/api/v1/move/241/"}, {"learn_type": "machine", "name": "Hidden-power", "resource_uri": "/api/v1/move/237/"}, {"learn_type": "machine", "name": "Iron-tail", "resource_uri": "/api/v1/move/231/"}, {"learn_type": "level up", "level": 27, "name": "Pursuit", "resource_uri": "/api/v1/move/228/"}, {"learn_type": "machine", "name": "Frustration", "resource_uri": "/api/v1/move/218/"}, {"learn_type": "machine", "name": "Return", "resource_uri": "/api/v1/move/216/"}, {"learn_type": "machine", "name": "Sleep-talk", "resource_uri": "/api/v1/move/214/"}, {"learn_type": "machine", "name": "Attract", "resource_uri": "/api/v1/move/213/"}, {"learn_type": "machine", "name": "Swagger", "resource_uri": "/api/v1/move/207/"}, {"learn_type": "machine", "name": "Endure", "resource_uri": "/api/v1/move/203/"}, {"learn_type": "machine", "name": "Icy-wind", "resource_uri": "/api/v1/move/196/"}, {"learn_type": "machine", "name": "Mud-slap", "resource_uri": "/api/v1/move/189/"}, {"learn_type": "machine", "name": "Protect", "resource_uri": "/api/v1/move/182/"}, {"learn_type": "egg move", "name": "Reversal", "resource_uri": "/api/v1/move/179/"}, {"learn_type": "machine", "name": "Curse", "resource_uri": "/api/v1/move/174/"}, {"learn_type": "machine", "name": "Snore", "resource_uri": "/api/v1/move/173/"}, {"learn_type": "egg move", "name": "Flame-wheel", "resource_uri": "/api/v1/move/172/"}, {"learn_type": "machine", "name": "Thief", "resource_uri": "/api/v1/move/168/"}, {"learn_type": "egg move", "name": "Fury-swipes", "resource_uri": "/api/v1/move/154/"}, {"learn_type": "machine", "name": "Defense-curl", "resource_uri": "/api/v1/move/111/"}, {"learn_type": "egg move", "name": "Screech", "resource_uri": "/api/v1/move/103/"}, {"learn_type": "egg move", "name": "Counter", "resource_uri": "/api/v1/move/68/"}, {"learn_type": "egg move", "name": "Bite", "resource_uri": "/api/v1/move/44/"}, {"learn_type": "machine", "name": "Headbutt", "resource_uri": "/api/v1/move/29/"}, {"learn_type": "machine", "name": "Substitute", "resource_uri": "/api/v1/move/164/"}, {"learn_type": "level up", "level": 34, "name": "Super-fang", "resource_uri": "/api/v1/move/162/"}, {"learn_type": "level up", "level": 14, "name": "Hyper-fang", "resource_uri": "/api/v1/move/158/"}, {"learn_type": "machine", "name": "Rest", "resource_uri": "/api/v1/move/156/"}, {"learn_type": "machine", "name": "Skull-bash", "resource_uri": "/api/v1/move/130/"}, {"learn_type": "machine", "name": "Swift", "resource_uri": "/api/v1/move/129/"}, {"learn_type": "machine", "name": "Bide", "resource_uri": "/api/v1/move/117/"}, {"learn_type": "level up", "level": 23, "name": "Focus-energy", "resource_uri": "/api/v1/move/116/"}, {"learn_type": "machine", "name": "Double-team", "resource_uri": "/api/v1/move/104/"}, {"learn_type": "machine", "name": "Mimic", "resource_uri": "/api/v1/move/102/"}, {"learn_type": "machine", "name": "Rage", "resource_uri": "/api/v1/move/99/"}, {"learn_type": "level up", "level": 7, "name": "Quick-attack", "resource_uri": "/api/v1/move/98/"}, {"learn_type": "machine", "name": "Toxic", "resource_uri": "/api/v1/move/92/"}, {"learn_type": "machine", "name": "Dig", "resource_uri": "/api/v1/move/91/"}, {"learn_type": "machine", "name": "Thunder", "resource_uri": "/api/v1/move/87/"}, {"learn_type": "machine", "name": "Thunderbolt", "resource_uri": "/api/v1/move/85/"}, {"learn_type": "machine", "name": "Bubblebeam", "resource_uri": "/api/v1/move/61/"}, {"learn_typ
e": "machine", "name": "Blizzard", "resource_uri": "/api/v1/move/59/"}, {"learn_type": "machine", "name": "Water-gun", "resource_uri": "/api/v1/move/55/"}, {"learn_type": "level up", "level": 1, "name": "Tail-whip", "resource_uri": "/api/v1/move/39/"}, {"learn_type": "machine", "name": "Double-edge", "resource_uri": "/api/v1/move/38/"}, {"learn_type": "machine", "name": "Take-down", "resource_uri": "/api/v1/move/36/"}, {"learn_type": "machine", "name": "Body-slam", "resource_uri": "/api/v1/move/34/"}, {"learn_type": "level up", "level": 1, "name": "Tackle", "resource_uri": "/api/v1/move/33/"}], "name": "Rattata", "national_id": 19, "pkdx_id": 19, "resource_uri": "/api/v1/pokemon/19/", "sp_atk": 25, "sp_def": 35, "species": "", "speed": 72, "sprites": [{"name": "rattata", "resource_uri": "/api/v1/sprite/20/"}], "total": 0, "types": [{"name": "normal", "resource_uri": "/api/v1/type/1/"}], "weight": "35"}]}
Finalizado
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
#NodeJS - Aula 03 - Exercícios
autor: Dariano Soares
##1. Por que quando requisitamos ao nosso servidor de Query String, **com o Chrome**, ele executa 2 requisições, sendo a última "vazia"?
São feita duas requisições uma para **trazer os dados** e a segunda para **trazer o favicon.ico**.
##2. Qual a DIFERENÇA entre o GET e o POST?
**GET** Recupera uma representação do recurso especificado. Uma requisição GET não deve alterar o estado do servidor, e é essencialmente uma operação de leitura.
**POST** É usado para se criar novos recursos no servidor. Usos típicos de requisição POST são o envio de formulários HTML e a adição de dados a uma base de dados.
Referencia -> Livro Pro Node.js para Desenvolvedores. Autor: Colin J. Ihrig
##3. Crie um Pokemon na nossa API com seu nome, depois modifique o seu nome pelo User do Github, colocando aqui a resposta de cada passo?
Após **adiconado** o pokemon Magneton a resposta foi:
```json
postData name=magneton&type=electric
Tamanho do postData 27
STATUS: 201
HEADERS: {
"server": "Cowboy",
"connection": "close",
"x-powered-by": "Express",
"access-control-allow-origin": "*",
"content-type": "application/json; charset=utf-8",
"content-length": "78",
"etag": "W/\"4e-2gRVPek+rPQoqO15ybRyGw\"",
"date": "Sat, 12 Dec 2015 22:03:33 GMT",
"via": "1.1 vegur"
}
Dados finalizados: {
"__v": 0,
"name": "magneton",
"type": "electric",
"_id": "566c99b5103f631100175e62"
}
```
Após **atualizar** para o nome do usuário do gitHub o resultado foi:
```json
STATUS: 202
HEADERS: : {
"server": "Cowboy",
"connection": "close",
"x-powered-by": "Express",
"access-control-allow-origin": "*",
"content-type": "application/json; charset=utf-8",
"content-length": "108",
"etag": "W/\"6c-Z+EiJ7w7xZR5Iy+oKrCjOA\"",
"date": "Sat, 12 Dec 2015 22:11:15 GMT",
"via": "1.1 vegur"
}
Dados finalizados: {
"data": {
"ok": 1,
"nModified": 1,
"n": 1,
"lastOp": "6227523371689574401",
"electionId": "565e25d106dca622271891c4"
}
}
```
##4. **Depois faça o DELETE**, criando o script para tal, colocando aqui a resposta.
```json
STATUS: 204
HEADERS: {
"server": "Cowboy",
"content-length": "0",
"connection": "close",
"x-powered-by": "Express",
"access-control-allow-origin": "*",
"date": "Sat, 12 Dec 2015 22:15:17 GMT",
"via": "1.1 vegur"
}
```
##5. Escolha uma **API externa** e crie um script para fazer um GET nela **mostrando o resultado com HTML**?
```js
'use strict';
const http = require('http');
const querystring = require('querystring');
const postData = querystring.stringify({
parent: 'http%3A%2F%2Flabs.bluesoft.com.br'
});
const options = {
host: 'accounts.google.com'
, method: 'GET'
, path: '/o/oauth2/postmessageRelay'
, headers: {
'Content-Type': 'text/html'
}
};
function callback(res) {
console.log('STATUS: ' + res.statusCode);
console.log('HEADERS: ' + JSON.stringify(res.headers));
let data = '';
res.setEncoding('utf8');
res.on('data', (dados) => {
data += dados;
});
res.on('end', () => {
console.log('Dados finalizados: ', data)
})
}
const req = http.request(options, callback);
req.on('error', (e) => {
console.log('ERRO: ' + e.message);
});
req.end();
```
Retorno:
```html
<!DOCTYPE html>
<html lang=en>
<meta charset=utf-8>
<meta name=viewport content="initial-scale=1, minimum-scale=1, width=device-width">
<title>Error 404 (Not Found)!!1</title>
<div id="af-error-container">
<a href=//www.google.com/><span id=logo aria-label=Google></span></a>
<p><b>404.</b> <ins>That’s an error.</ins>
<p>The requested URL was not found on this server. <ins>That’s all we know.</ins>
</div>
</html>
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 03 - Exercício
**user:** [filipe1309](https://github.com/filipe1309)
**autor:** Filipe Leuch Bonfim
## Por que quando requisitamos ao nosso servidor de *Query String*, **com o Chrome**, ele executa 2 requisições, sendo a última "*vazia*"?
Este é um **bug**, [já conhecido do Chrome](http://crbug.com/39402), que envia um `request` a mais, solicitando o `favicon.ico` da aplicação.
## Qual a DIFERENÇA entre o GET e o POST?
A principal diferença entre estes métodos HTTP é a **visibilidade**.
| - | GET | POST|
|------------------------------ | -------------------------------------------------------------------------------- |-----|
|**Quando usar**| poucos dados, e sem necessidade de segurança | grande quantidade de dados e necessidade de segurança|
|**Visibilidade** | os parâmetros do request são passados, de maneira visível, junto á URL | os parâmetros são encapsulados junto com a requisição HTTP, não sendo "visível" pela URL |
|**limite de caracteres** | Sim | Não |
|**Velocidade** | + Rápido | + Lento devido ao encapsulamento |
|**Tipo dos dados** | somente `string` | tanto `strings`, quanto dados binários |
|**Armazenamento [Cache/Favoritos]** | Sim | Não |
## Crie um Pokemon na nossa API com seu nome, depois modifique seu nome pelo seu User do Github.
#### Criando
##### http-request-post.js
```js
// ...
const postData = querystring.stringify({
name: 'Filipe Leuch Bonfim'
, type: 'estudante'
});
// ...
```
```
> node http-request-post.js
postData name=Filipe%20Leuch%20Bonfim&type=estudante
Tamanho do postData 43
STATUS: 201
HEADERS:
{"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"90","etag":"W/\"5a-mfMhUZqUwCgMFkJAaSZciQ\"","date":"Thu, 25 Feb 2016 03:17:12 GMT","via":"1.1 vegur"}
Dados finalizados: {"__v":0,"name":"Filipe Leuch Bonfim","type":"estudante","_id":"56ce7238beca0911007b63d4"}
```
#### Modificando
##### http-request-put.js
```js
// ...
const postData = querystring.stringify({
name: 'filipe1309'
, type: 'estudante'
});
// ...
const options = {
host: 'webschool-io.herokuapp.com'
, method: 'PUT'
, path: '/api/pokemons/56ce7238beca0911007b63d4'
, headers: {
'Content-Type': 'application/x-www-form-urlencoded'
, 'Content-Length': postData.length
}
};
// ...
```
```
> node http-request-put.js
postData name=filipe1309&type=estudante
Tamanho do postData 30
STATUS: 202
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"108","etag":"W/\"6c-gdBvthDD89Q1hnGOpDGo5A\"","date":"Thu, 25 Feb 2016 03:19:07 GMT","via":"1.1 vegur"}
Dados finalizados: {"data":{"ok":1,"nModified":1,"n":1,"lastOp":"6255063011229171713","electionId":"565e25d106dca622271891c4"}}
```
## **Depois faça o DELETE**, criando o script para tal, colocando aqui a resposta.
```
node http-request-del.js
STATUS: 204
HEADERS: {"server":"Cowboy","content-length":"0","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","date":"Thu, 25 Feb 2016 03:43:11 GMT","via":"1.1 vegur"}
Dados finalizados:
```
## Escolha uma **API externa** e crie um script para fazer um GET nela **mostrando o resultado com HTML**.
```js
'use strict';
const https = require('https');
const options = {
host: 'hacker-news.firebaseio.com'
, path: '/v0/item/11177200.json'
};
function callback(res) {
console.log('STATUS: ' + res.statusCode);
console.log('HEADERS: ' + JSON.stringify(res.headers));
let data = '';
res.setEncoding('utf8');
res.on('data', function (chunk) {
data += chunk;
});
res.on('end', function() {
let data_json = JSON.parse(data);
let data_html = '<html><body><a href="';
data_html += data_json.url + '"><h1>';
data_html += data_json.title + '</h1></a></body></html>';
console.log('Dados finalizados: ', data);
console.log('Dados HTML: ',data_html);
})
}
const req = https.request(options, callback);
req.on('error', function(e) {
console.log('ERROOOO: ' + e.message);
});
req.end();
```
#### Saída
```
STATUS: 200
HEADERS: {"content-length":"559","content-type":"application/json; charset=utf-8","cache-control":"no-cache","strict-transport-security":"max-age=31556926; includeSubDomains; preload","connection":"close"}
Dados finalizados: {"by":"sbuk","descendants":143,"id":11177200,"kids":[11177782,11179326,11179315,11179298,11178441,11178062,11178125,11178816,11178621,11178617,11179227,11179351,11178575,11178592,11178842,11178320,11177835,11177993,11179134,11178197,11177614,11177594,11177730,11178786,11177924,11178156,11178104,11178544,11177437,11179222],"score":527,"time":1456429470,"title":"Microsoft, Google, Facebook Back Apple in Blocked Phone Case","type":"story","url":"http://www.bloomberg.com/news/articles/2016-02-25/microsoft-says-it-will-file-an-amicus-brief-to-support-apple"}
Dados HTML: <html><body><a href="http://www.bloomberg.com/news/articles/2016-02-25/microsoft-says-it-will-file-an-amicus-brief-to-support-apple"><h1>Microsoft, Google, Facebook Back Apple in Blocked Phone Case</h1></a></body></html>
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 03 - Exercício
**user:** [xereda](https://github.com/xereda)
**autor:** Jackson Ricardo Schroeder
**date:** 1465274797795
## Por que quando requisitamos ao nosso servidor de *Query String*, **com o Chrome**, ele executa 2 requisições, sendo a última "*vazia*"?
Isso realmente ocorre apenas no Google Chrome. O Google Chrome realiza mais uma requisição, mas dessa vez para recuperar o favicon.ico, caso exista no servidor.
## Qual a DIFERENÇA entre o GET e o POST?
Embora o método POST também retorne informações para o requisitante, convencionou-se que POST _(inserir/Create)_ seria um método mais adequado para criar um novo documento, ficando para o GET o uso na recuperação das informações _(ler/Read/retrieve)_.
Já com base no **protocolo HTTP**, tecnicamente os dois métodos possuem algumas diferentes características. O método GET possui restrição de tamanho, e os parâmetros são repassados de forma explícita na requisição, num padrão URL (querystring). O método POST, tem suporte para envio de dados em maior volume e permite o envio de dados binários. Um exemplo de uso do método post são os formulários de upload de arquivos.
## Crie um Pokemon na nossa API com seu nome, depois modifique seu nome pelo seu User do Github.
**POST**
```js
// SCRIPT http-request-post.js
"use strict";
const http = require("http");
const options = {
host: "webschool-io.herokuapp.com",
method: "DELETE",
path: "/api/pokemons/5756594a48075f1100eebd3b"
};
function callback(res) {
console.log("STATUS: " + res.statusCode);
console.log("HEADERS: " + JSON.stringify(res.headers));
let data = "";
res.setEncoding("utf8");
res.on("data", (dados) => {
data += dados;
});
res.on("end", () => {
console.log("Dados Finalizados: " + data);
});
}
const req = http.request(options, callback);
req.on("error", (e) => {
console.log("ERROOOOO: " + e.message);
});
req.end();
```
```js
xereda@macminixereda:~/S/b/n/aula03$ node http-request-post.js
name=Jackson%20Ricardo%20Schroeder&type=aluno
STATUS: 201
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"91","etag":"W/\"5b-+kVJUd6DgHh39yVynxbEtQ\"","date":"Tue, 07 Jun 2016 05:20:42 GMT","via":"1.1 vegur"}
Dados Finalizados: {"__v":0,"name":"Jackson Ricardo Schroeder","type":"aluno","_id":"575659aa48075f1100eebd3c"}
```
**PUT**
```js
"use strict";
const http = require("http");
const querystring = require("querystring");
const postData = querystring.stringify({
name: "xereda",
type: "aluno"
});
const options = {
host: "webschool-io.herokuapp.com",
method: "PUT",
path: "/api/pokemons/575659aa48075f1100eebd3c",
headers: {
"Content-Type": "application/x-www-form-urlencoded",
"Content-length": postData.length
}
};
function callback(res) {
console.log("STATUS: " + res.statusCode);
console.log("HEADERS: " + JSON.stringify(res.headers));
let data = "";
res.setEncoding("utf8");
res.on("data", (dados) => {
data += dados;
});
res.on("end", () => {
console.log("Dados Finalizados: " + data);
});
}
const req = http.request(options, callback);
req.on("error", (e) => {
console.log("ERROOOOO: " + e.message);
});
console.log(postData);
req.write(postData);
req.end();
```
```js
xereda@macminixereda:~/S/b/n/aula03$ node http-request-put.js
name=xereda&type=aluno
STATUS: 202
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"108","etag":"W/\"6c-KXqz1ydQydNDOG0DgOGl5A\"","date":"Tue, 07 Jun 2016 05:26:39 GMT","via":"1.1 vegur"}
Dados Finalizados: {"data":{"ok":1,"nModified":1,"n":1,"lastOp":"6293317649279483905","electionId":"56ee12f2563048036a1e77e7"}}
```
## **Depois faça o DELETE**, criando o script para tal, colocando aqui a resposta.
```js
"use strict";
const http = require("http");
const options = {
host: "webschool-io.herokuapp.com",
method: "DELETE",
path: "/api/pokemons/575659aa48075f1100eebd3c"
};
function callback(res) {
console.log("STATUS: " + res.statusCode);
console.log("HEADERS: " + JSON.stringify(res.headers));
let data = "";
res.setEncoding("utf8");
res.on("data", (dados) => {
data += dados;
});
res.on("end", () => {
console.log("Dados Finalizados: " + data);
});
}
const req = http.request(options, callback);
req.on("error", (e) => {
console.log("ERROOOOO: " + e.message);
});
req.end();
```
```js
xereda@macminixereda:~/S/b/n/aula03$ node http-request-delete.js
STATUS: 204
HEADERS: {"server":"Cowboy","content-length":"0","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","date":"Tue, 07 Jun 2016 05:30:25 GMT","via":"1.1 vegur"}
Dados Finalizados:
```
## Escolha uma **API externa** e crie um script para fazer um GET nela **mostrando o resultado com HTML**.
```js
'use strict';
const http = require('http');
const app = {
createServer: () => {
this.server = http.createServer((req, response) => {
response.writeHead(200, { 'Content-Type': 'text/html' });
http.get(app.optionsRequest, res => {
let data = '';
res.on('data', chunck => data += chunck);
res.on('end', () => {
var json = JSON.parse(data)
, html = app.htmlHelper.build(json);
response.write(html);
response.end();
});
});
});
},
htmlHelper: {
build: (data) => {
var html = '';
html += app.htmlHelper.buildHeader();
html += app.htmlHelper.buildBody(data);
html += app.htmlHelper.buildFooter();
return html;
},
buildHeader: () => {
var html = '<!doctype html>' +
'<html>' +
'<head>' +
'<meta charset="utf-8">' +
'</head>' +
'<body>';
return html;
},
buildBody: data => {
var html = '<h1>Usando API de times de futebol</h1>';
html += '<ul>';
let x = 0;
let clube = [];
for(clube in data.teams) {
//console.log("x eh: " + x);
html += '<li>Nome do time: <b><i>' + data.teams[clube].name + '</i></b></li>';
html += '<li>Apelido: <b><i>' + data.teams[clube].shortName + '</i></b></li>';
html += '<li>Abreviatura: <b><i>' + data.teams[clube].code + '</i></b></li>';
html += '<hr>';
}
html += '</ul>';
return html;
},
buildFooter: () =>{ return '</body></html>' }
},
optionsRequest: {
hostname: 'api.football-data.org',
path: '/v1/soccerseasons/398/teams',
headers: {
'X-Auth-Token': 'bb738b800597467f98bc52e6e6093b69'
}
},
listen: () => this.server.listen(3000, () => console.log('Estou pronto!')),
server: null
};
app.createServer();
app.listen();
```
**HTML**
```
<!doctype html><html><head><meta charset="utf-8"></head><body><h1>Usando API de times de futebol</h1><ul><li>Nome do time: <b><i>Manchester United FC</i></b></li><li>Apelido: <b><i>ManU</i></b></li><li>Abreviatura: <b><i>MUFC</i></b></li><hr><li>Nome do time: <b><i>Tottenham Hotspur FC</i></b></li><li>Apelido: <b><i>Spurs</i></b></li><li>Abreviatura: <b><i>THFC</i></b></li><hr><li>Nome do time: <b><i>AFC Bournemouth</i></b></li><li>Apelido: <b><i>Bournemouth</i></b></li><li>Abreviatura: <b><i>AFCB</i></b></li><hr><li>Nome do time: <b><i>Aston Villa FC</i></b></li><li>Apelido: <b><i>Aston Villa</i></b></li><li>Abreviatura: <b><i>AVFC</i></b></li><hr><li>Nome do time: <b><i>Everton FC</i></b></li><li>Apelido: <b><i>Everton</i></b></li><li>Abreviatura: <b><i>EFC</i></b></li><hr><li>Nome do time: <b><i>Watford FC</i></b></li><li>Apelido: <b><i>Watford</i></b></li><li>Abreviatura: <b><i>Watfordfc</i></b></li><hr><li>Nome do time: <b><i>Leicester City FC</i></b></li><li>Apelido: <b><i>Foxes</i></b></li><li>Abreviatura: <b><i>LCFC</i></b></li><hr><li>Nome do time: <b><i>Sunderland AFC</i></b></li><li>Apelido: <b><i>Sunderland</i></b></li><li>Abreviatura: <b><i>SUN</i></b></li><hr><li>Nome do time: <b><i>Norwich City FC</i></b></li><li>Apelido: <b><i>Norwich</i></b></li><li>Abreviatura: <b><i>NCFC</i></b></li><hr><li>Nome do time: <b><i>Crystal Palace FC</i></b></li><li>Apelido: <b><i>Crystal</i></b></li><li>Abreviatura: <b><i>CRY</i></b></li><hr><li>Nome do time: <b><i>Chelsea FC</i></b></li><li>Apelido: <b><i>Chelsea</i></b></li><li>Abreviatura: <b><i>CFC</i></b></li><hr><li>Nome do time: <b><i>Swansea City FC</i></b></li><li>Apelido: <b><i>Swans</i></b></li><li>Abreviatura: <b><i>SWA</i></b></li><hr><li>Nome do time: <b><i>Newcastle United FC</i></b></li><li>Apelido: <b><i>Newcastle</i></b></li><li>Abreviatura: <b><i>NUFC</i></b></li><hr><li>Nome do time: <b><i>Southampton FC</i></b></li><li>Apelido: <b><i>Southampton</i></b></li><li>Abreviatura: <b><i>SFC</i></b></li><hr><li>Nome do time: <b><i>Arsenal FC</i></b></li><li>Apelido: <b><i>Arsenal</i></b></li><li>Abreviatura: <b><i>AFC</i></b></li><hr><li>Nome do time: <b><i>West Ham United FC</i></b></li><li>Apelido: <b><i>West Ham</i></b></li><li>Abreviatura: <b><i>WHU</i></b></li><hr><li>Nome do time: <b><i>Stoke City FC</i></b></li><li>Apelido: <b><i>Stoke</i></b></li><li>Abreviatura: <b><i>SCFC</i></b></li><hr><li>Nome do time: <b><i>Liverpool FC</i></b></li><li>Apelido: <b><i>Liverpool</i></b></li><li>Abreviatura: <b><i>LFC</i></b></li><hr><li>Nome do time: <b><i>West Bromwich Albion FC</i></b></li><li>Apelido: <b><i>West Bromwich</i></b></li><li>Abreviatura: <b><i>WBA</i></b></li><hr><li>Nome do time: <b><i>Manchester City FC</i></b></li><li>Apelido: <b><i>ManCity</i></b></li><li>Abreviatura: <b><i>MCFC</i></b></li><hr></ul></body></html>
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 03 - Exercício
**User:** [carloshenriqueribeiro](https://github.com/carloshenriqueribeiro)
**Autor:** Carlos Henrique Ribeiro
**Date:** 1452720577119
# 1. Por que quando requisitamos ao nosso servidor de Query String, **com o Chrome**, ele executa 2 requisições, sendo a última "vazia"?
Porque atumaticamente ele faz uma segunda requisição solicitando o "favicon.ico", esse favicon hoje é usado para melhor identificação da página, fica à esquena do title na aba do navegador.
# 2. Qual a **DIFERENÇA** entre o **GET** e o **POST**?
** GET **
O GET foi feito para se enviar pedidos para receber informações de uma url, e é usado para enviar parâmetros via URL (querystring). Ele possui uma limitação de caracteres em seu envio de 1.024 caracteres, o que torna o conteúdo bem limitado.
** POST **
Já o POST foi feito para enviar informações e não apenas consulta-las (como é o caso do GET). Os parâmetros não são enviados via url e o limite do POST é "ilimitado", sendo esse limite sendo apenas definido via servidor, o que geralmente garante o POST de bastante informação sem problema nenhum.
# 3. Crie um Pokemon na nossa API com o seu nome, depois modifique seu nome pelo seu user do Github, colocando aqui a resposta de cada passo.
~~~ js
//Criando o "Pokemon"
STATUS: 201
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"78","etag":"W/\"4e-GtkDpHj2/UkF+JW96KfJcQ\"","date":"Thru, 1 Ago 2017 18:39:01 GMT","via":"1.1 vegur"}
Dados finalizados: {"__v":0,"name":"Carlitos ","type":"aluno","_id":"5696c65a2f90f71100f42eca"}
//Removendo
STATUS: 202
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"108","etag":"W/\"6c-BsH4onU2gQgfl729cawThQ\"","date":"Thru, 1 Ago 2017 18:41:47 GMT","via":"1.1 vegur"}
Dados finalizados: {"data":{"ok":1,"nModified":1,"n":1,"lastOp":"6239393325560889345","electionId":"565e25d106dca622271891c4"}}
~~~
# 4. Depois faça o DELETE, criando o script para tal, colocndo aqui a resposta.
~~~ js
//Excluindo
STATUS: 204
HEADERS: {"server":"Cowboy","content-length":"0","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","date":"Thru, 1 Ago 2017 18:53:47 GMT","via":"1.1 vegur"}
Dados finalizados:
~~~
# 5. Escolha uma API externa e crie um script para fazer um GET nela mostrando o resultado em HTML.
~~~ js
//API
host: 'pokeapi.co',
path: '/api/v1/type/?limit=10&offset=1'
//Retorno
STATUS: 200
HEADERS: {"server":"nginx/1.1.19","date":"Thru, 1 Ago 2017 19:32:47 GMT","content-type":"application/json","transfer-encoding":"chunked","connection":"close","vary":"Accept","x-frame-options":"SAMEORIGIN","cache-control":"s-maxage=360, max-age=360"}
<ul>
<li>Fighting</li>
<li>Flying</li>
<li>Poison</li>
<li>Ground</li>
<li>Rock</li>
<li>Bug</li>
<li>Ghost</li>
<li>Steel</li>
<li>Fire</li>
<li>Water</li>
</ul>
~~~
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 03 - Exercício
**User:** ronal2do
**Author:** Ronaldo Lima
**Date:** 1468022470175
##### [Exercício-01](#por-que-quando-requisitamos-ao-nosso-servidor-de-query-string-com-o-chrome-ele-executa-2-requisi%C3%A7%C3%B5es-sendo-a-%C3%BAltima-vazia)
##### [Exercício-02](#qual-a-diferen%C3%A7a-entre-o-get-e-o-post)
##### [Exercício-03](#crie-um-pokemon-na-nossa-api-com-seu-nome-depois-modifique-seu-nome-pelo-seu-user-do-github-colocando-aqui-a-resposta-de-cada-passo)
##### [Exercício-04](#depois-fa%C3%A7a-o-delete-criando-o-script-para-tal-colocando-aqui-a-resposta)
##### [Exercício-05](#escolha-uma-api-externa-e-crie-um-script-para-fazer-um-get-nela-mostrando-o-resultado-em-html)
# Por que quando requisitamos ao nosso servidor de Query String, com o Chrome, ele executa 2 requisições, sendo a última "vazia"?
Pois em cada requisição, o Chrome também faz a solicitação de um `favicon`.
# Qual a diferença entre o GET e o POST?
O `GET` é utilizado para quando queremos acessar alguma informação no servidor, outra coisa, o mesmo é visualizado através da url(a querystring após o endereço do servidor), e só pode enviar texto.
O `POST` é utilizado para quando queremos gravar alguma informação no servidor, pode enviar diversos tipos de dados(texto, arquivos, etc...).
# Crie um Pokemon na nossa API com seu nome, depois modifique seu nome pelo seu User do Github, colocando aqui a resposta de cada passo.
### Cadastrando com o meu nome
```js
'use strict';
const http = require('http');
const querystring = require('querystring');
const postData = querystring.stringify({
name: '2D Lima'
, type: 'Lokoooo!'
});
const options = {
host: 'webschool-io.herokuapp.com'
, path: '/api/pokemons'
, method: 'POST'
, headers: {
'Content-Type': 'application/x-www-form-urlencoded'
, 'Content-Length': postData.length
}
};
function callback(res) {
console.log('STATUS: ' + res.statusCode);
console.log('HEADERS: ' + JSON.stringify(res.headers));
let data = '';
res.setEncoding('utf8');
res.on('data', (chunk) => {
data += chunk;
});
res.on('end', () => {
console.log('Dados finalizados: ', data)
})
}
const req = http.request(options, callback);
req.on('error', (e) => {
console.log('ERROOOO: ' + e.message);
});
req.write(postData);
req.end();
```
### Saída no terminal
```js
STATUS: 201
HEADERS: {"server":"Cowboy","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"77","etag":"W/\"4d-K1XAJt0nixO1Ke2TlcK+0g\"","date":"Sat, 09 Jul 2016 02:39:50 GMT","via":"1.1 vegur"}
Dados finalizados: {"__v":0,"name":"2D Lima","type":"Lokoooo!","_id":"578063f62d78cb11006de9c4"}
```
### Modificando com o meu user do github
```js
'use strict';
const http = require('http');
const querystring = require('querystring');
const postData = querystring.stringify({
name: 'ronal2do'
, type: 'Lokoo!'
});
const options = {
host: 'webschool-io.herokuapp.com'
, path: '/api/pokemons/578063f62d78cb11006de9c4'
, method: 'PUT'
, headers: {
'Content-Type': 'application/x-www-form-urlencoded'
, 'Content-Length': postData.length
}
};
function callback(res) {
console.log('STATUS: ' + res.statusCode);
console.log('HEADERS: ' + JSON.stringify(res.headers));
let data = '';
res.setEncoding('utf8');
res.on('data', (chunk) => {
data += chunk;
});
res.on('end', () => {
console.log('Dados finalizados: ', data)
})
}
const req = http.request(options, callback);
req.on('error', (e) => {
console.log('ERROOOO: ' + e.message);
});
req.write(postData);
req.end();
```
### Saída no terminal
```js
STATUS: 202
HEADERS: {"server":"Cowboy","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"108","etag":"W/\"6c-KUssZB1YDVSRLM9IZUNAAA\"","date":"Sat, 09 Jul 2016 02:53:02 GMT","via":"1.1 vegur"}
Dados finalizados: {"data":{"ok":1,"nModified":1,"n":1,"lastOp":"6305152788145897473","electionId":"576451dfece94f32689e021d"}}
```
# Depois faça o delete, criando o script para tal, colocando aqui a resposta.
```js
'use strict';
const http = require('http');
const querystring = require('querystring');
const postData = querystring.stringify({
name: 'ronal2do'
, type: 'Lokoo!'
});
const options = {
host: 'webschool-io.herokuapp.com'
, path: '/api/pokemons/578063f62d78cb11006de9c4'
, method: 'DELETE'
, headers: {
'Content-Type': 'application/x-www-form-urlencoded'
, 'Content-Length': postData.length
}
};
function callback(res) {
console.log('STATUS: ' + res.statusCode);
console.log('HEADERS: ' + JSON.stringify(res.headers));
let data = '';
res.setEncoding('utf8');
res.on('data', (chunk) => {
data += chunk;
});
res.on('end', () => {
console.log('Dados finalizados: ', data)
})
}
const req = http.request(options, callback);
req.on('error', (e) => {
console.log('ERROOOO: ' + e.message);
});
req.write(postData);
req.end();
```
### Saída no terminal
```js
STATUS: 204
HEADERS: {"server":"Cowboy","content-length":"0","x-powered-by":"Express","access-control-allow-origin":"*","date":"Sat, 09 Jul 2016 02:57:29 GMT","via":"1.1 vegur"}
Dados finalizados:
```
# Escolha uma API externa e crie um script para fazer um GET nela mostrando o resultado em HTML.
### Código
```js
// API do Magic TCG
'use strict';
const http = require('http');
const options = {
host: 'api.deckbrew.com'
, path: '/mtg/cards/about-face'
};
function callback(res) {
console.log('STATUS: ' + res.statusCode);
console.log('HEADERS: ' + JSON.stringify(res.headers));
let data = '';
res.setEncoding('utf8');
res.on('data', (chunk) => {
data += chunk;
});
res.on('end', () => {
console.log('Dados finalizados: ', data)
})
}
const req = http.request(options, callback);
req.on('error', (e) => {
console.log('ERROOOO: ' + e.message);
});
req.end();
```
### Resultado Terminal com JSON
```js
STATUS: 200
HEADERS: {"date":"Sat, 09 Jul 2016 03:04:03 GMT","content-type":"application/json; charset=utf-8","content-length":"1186","set-cookie":["__cfduid=d62533328f17b2bacebe1331b35537e781468033443; expires=Sun, 09-Jul-17 03:04:03 GMT; path=/; domain=.deckbrew.com; HttpOnly"],"access-control-allow-origin":"*","access-control-expose-headers":"link,content-length","cache-control":"public,max-age=3600","disclaimer":"This API is not produced, endorsed, supported, or affiliated with Wizards of the Coast.","license":"The textual information presented through this API about Magic: The Gathering is copyrighted by Wizards of the Coast.","pricing":"store.tcgplayer.com allows you to buy cards from any of our vendors, all at the same time, in a simple checkout experience. Shop, Compare & Save with TCGplayer.com!","strict-transport-security":"max-age=86400","via":"1.1 vegur","server":"cloudflare-nginx","cf-ray":"2bf88be07bef07bb-MIA"}
Dados finalizados: {
"name": "About Face",
"id": "about-face",
"url": "https://api.deckbrew.com/mtg/cards/about-face",
"store_url": "http://store.tcgplayer.com/magic/urzas-legacy/about-face?partner=DECKBREW",
"types": [
"instant"
],
"colors": [
"red"
],
"cmc": 1,
"cost": "{R}",
"text": "Switch target creature's power and toughness until end of turn.",
"formats": {
"commander": "legal",
"legacy": "legal",
"vintage": "legal"
},
"editions": [
{
"set": "Urza's Legacy",
"set_id": "ULG",
"rarity": "common",
"artist": "Melissa A. Benson",
"multiverse_id": 12414,
"flavor": "The overconfident are the most vulnerable.",
"number": "73",
"layout": "normal",
"price": {
"low": 0,
"median": 0,
"high": 0
},
"url": "https://api.deckbrew.com/mtg/cards?multiverseid=12414",
"image_url": "https://image.deckbrew.com/mtg/multiverseid/12414.jpg",
"set_url": "https://api.deckbrew.com/mtg/sets/ULG",
"store_url": "http://store.tcgplayer.com/magic/urzas-legacy/about-face?partner=DECKBREW",
"html_url": "https://deckbrew.com/mtg/cards/12414"
}
]
}
```
### Resultado HTML
```js
// API do Magic TCG
'use strict';
const http = require('http');
const json2Html = require('node-json2html');
const options = {
host: 'api.deckbrew.com'
, path: '/mtg/cards/about-face'
};
function callback(res){
console.log('STATUS: ' + res.statusCode);
console.log('HEADERS: ' + JSON.stringify(res.headers));
res.setEncoding('utf8');
let dados = '';
res.on('data', (chunk) => {
dados += chunk;
});
res.on('end', () => {
let js = JSON.parse(dados);
console.log('<ul>');
console.log('<li> Nome: ' + js.name + '</li>');
console.log('<li> id: ' + js.id + '</li>');
console.log('<li> url: ' + js.url + '</li>');
console.log('<li> text: ' + js.text + '</li>');
console.log('<li> power: ' + js.power + '</li>');
console.log('<ul>');
})
}
const req = http.request(options, callback);
req.on('erros', (e) => {
console.log('ERRO: ' + e.message);
});
req.end();
```
```js
STATUS: 200
HEADERS: {"date":"Sat, 09 Jul 2016 03:31:51 GMT","content-type":"application/json; charset=utf-8","content-length":"1186","set-cookie":["__cfduid=ddf6689c13114b06f1204dd2355c37aac1468035111; expires=Sun, 09-Jul-17 03:31:51 GMT; path=/; domain=.deckbrew.com; HttpOnly"],"access-control-allow-origin":"*","access-control-expose-headers":"link,content-length","cache-control":"public,max-age=3600","disclaimer":"This API is not produced, endorsed, supported, or affiliated with Wizards of the Coast.","license":"The textual information presented through this API about Magic: The Gathering is copyrighted by Wizards of the Coast.","pricing":"store.tcgplayer.com allows you to buy cards from any of our vendors, all at the same time, in a simple checkout experience. Shop, Compare & Save with TCGplayer.com!","strict-transport-security":"max-age=86400","via":"1.1 vegur","server":"cloudflare-nginx","cf-ray":"2bf8b49549172e7b-MIA"}
<ul>
<li> Nome: About Face</li>
<li> id: about-face</li>
<li> url: https://api.deckbrew.com/mtg/cards/about-face</li>
<li> text: Switch target creature's power and toughness until end of turn.</li>
<li> power: undefined</li>
<ul>
sh-3.2#
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 03 - Exercício
**user:** [DouglasHennrich](https://github.com/DouglasHennrich)
**autor:** Douglas Hennrich
## Por que quando requisitamos ao nosso servidor de *Query String*, **com o Chrome**, ele executa 2 requisições, sendo a última "*vazia*"?
Isso ocorre, pois o Chrome faz a primeira requisição para puxar os dados da `Querystring` e a segunda requisição é para puxar o `fav.icon` do site
## Qual a DIFERENÇA entre o GET e o POST?
* **GET**
- As informações são enviadas como `String` anexada a `URL`
- Limite de tamanho da mensagem a ser enviada
- Envia somente `String`
- Informações enviadas ficam em `cache`
* **POST**
- As informações são encapsuladas junto ao corpo da requisição `HTTP` e não podem ser vistas na `URL`
- Sem limites de comprimento da mensagem enviada
- Envia qualquer tipo de dados
- As informações enviadas **NÃO** ficam gravadas em `cache`
## Crie um Pokemon na nossa API com seu nome, depois modifique seu nome pelo seu User do Github.
```js
STATUS: 201
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"83","etag":"W/\"53-NXiCwjw6In/DOcTmzTUjpQ\"","date":"Sun, 13 Dec 2015 01:59:39 GMT","via":"1.1 vegur"}
Dados Finalizados: {"__v":0,"name":"Douglas Hennrich","type":"aluno","_id":"566cd10b25ff7511008dcfd2"}
```
---
```js
STATUS: 202
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"108","etag":"W/\"6c-aCp4f3tJR0UHoIZ68ib41w\"","date":"Sun, 13 Dec 2015 02:00:48 GMT","via":"1.1 vegur"}
Dados Finalizados: {"data":{"ok":1,"nModified":1,"n":1,"lastOp":"6227582526274142209","electionId":"565e25d106dca622271891c4"}}
```
## **Depois faça o DELETE**, criando o script para tal, colocando aqui a resposta.
```js
STATUS: 204
HEADERS: {"server":"Cowboy","content-length":"0","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","date":"Sun, 13 Dec 2015 02:02:28 GMT","via":"1.1 vegur"}
Dados Finalizados:
```
## Escolha uma **API externa** e crie um script para fazer um GET nela **mostrando o resultado com HTML**.
```html
STATUS: 200
HEADERS: {"content-type":"text/html","date":"Sun, 13 Dec 2015 02:20:00 GMT","connection":"close","transfer-encoding":"chunked"}
Dados finalizados:
<html><body><h1>Pokemons</h1><ul><li>Pokemon: Bulbassauro</li><li>Pokemon: Charmander</li><li>Pokemon: Squirtle</li><li>Pokemon: Pikachu</li></ul></body></html>
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 03 - Exercício
**user:** [davidsonsns](https://github.com/davidsonsns)
**autor:** Davidson da Silva Nascimento
### Por que quando requisitamos ao nosso servidor de *Query String*, **com o Chrome**, ele executa 2 requisições, sendo a última "*vazia*"?
Na primeira requisição é enviado os dados normalmente. Na segunda o Chrome requisita o **favicon** ao servidor.
[Removendo requisição favicon no node.js](https://gist.github.com/kentbrew/763822)
### Qual a DIFERENÇA entre o GET e o POST?
#### GET
+ Requisita informações no serviço/api
+ Requisição feita totalmente via URL(dados enviados juntamente a url)
+ Tamanho limitado de capacidade de envio
+ Mais rápido devido sua simplicidade
+ Apenas dados do tipo texto pode ser enviado
+ Requisição armazenada em cache
+ Método(method) padrão de formulários
+ Limitado ao padrão ASCII
+ Para indicar o início dos dados é utilizado a interrogação **(?)**, e para se separar cada valor se usa o símbolo **&**
Exemplo:
```
http://www.url.com.br?valor1=be&valor2=mean
```
#### POST
+ Cria entidades no serviço/api
+ Dados enviados no corpo da requisição HTTP.
+ Sem limitação de espaço
+ O encaplulamento da mensagem gera uma demora no envio
+ Transposta qualquer tipo de dado
+ Pode usar o atributo “enctype” com o valor “multipart/form-data”, que faz uso do padrão UCS(Universal Multiple-Octet Coded Character Set)
Exemplo:
```
POST /servlet/default.jsp HTTP/1.1
Accept: text/plain; text/html
Accept-Language: en-gb
Connection: Keep-Alive
Host: localhost
Referer: http://localhost/ch8/SendDetails.htm
User-Agent: Mozilla/4.0 (compatible; MSIE 4.01; Windows 98)
Content-Length: 33
Content-Type: application/x-www-form-urlencoded
Accept-Encoding: gzip, deflate
LastName=Magalhaes&FirstName=Guilherme
```
### Crie um Pokemon na nossa API com seu nome, depois modifique seu nome pelo seu User do Github.
##### Criado
```js
STATUS:201
HEADERS:{
"server":"Cowboy",
"connection":"close",
"x-powered-by":"Express",
"access-control-allow-origin":"*",
"content-type":"application/json; charset=utf-8",
"content-length":"86",
"etag":"W/\"56-dg3rEt0+ozh6uDqbY0CXAQ\"",
"date":"Tue, 22 Mar 2016 23:55:39 GMT",
"via":"1.1 vegur"
}
Dados finalizados:{
"__v":0,
"name":"Davidson Nascimento",
"type":"aluno",
"_id":"56f1db7bcb11f71100f8d2b2"
}
```
##### Modificado
```js
STATUS:202
HEADERS:{
"server":"Cowboy",
"connection":"close",
"x-powered-by":"Express",
"access-control-allow-origin":"*",
"content-type":"application/json; charset=utf-8",
"content-length":"108",
"etag":"W/\"6c-dn2tbrpwX9BFx5AlJ5P7/A\"",
"date":"Tue, 22 Mar 2016 23:58:17 GMT",
"via":"1.1 vegur"
}
Dados finalizados:{
"data":{
"ok":1,
"nModified":1,
"n":1,
"lastOp":"6265030556581363713",
"electionId":"56ee12f2563048036a1e77e7"
}
}
```
### **Depois faça o DELETE**, criando o script para tal, colocando aqui a resposta.
```js
STATUS:204
HEADERS:{
"server":"Cowboy",
"content-length":"0",
"connection":"close",
"x-powered-by":"Express",
"access-control-allow-origin":"*",
"date":"Tue, 22 Mar 2016 23:59:47 GMT",
"via":"1.1 vegur"
}
Dados finalizados:
```
### Escolha uma **API externa** e crie um script para fazer um GET nela **mostrando o resultado com HTML**.
#### GET
```js
// file: http-request.js
'use strict';
const http = require('http');
const options = {
host: 'api.randomuser.me',
path: '/?gender=female&nat=br',
method: 'GET',
headers: {
'User-Agent': 'Chrome/46.0.2490.86',
'Content-Type': 'text/html'
}
};
function callback(res) {
let status = 'STATUS: ' + res.statusCode;
let headers = 'HEADERS: ' + JSON.stringify(res.headers);
let data = '';
res.setEncoding('utf8');
res.on('data', (chunk) => {
data += chunk;
});
res.on('end', () => {
let body = '<html><body><h4>' + status + '</h4><br>' + headers + '<br><br><code>' + data + '</code></body></html>'
console.log(body)
})
}
const req = http.request(options, callback);
req.on('error', (e) => {
console.log('ERROOOO: ' + e.message);
});
req.end();
```
#### Resultado
```js
<html><body><h4>STATUS: 200</h4><br>HEADERS: {"server":"nginx","date":"Wed, 23 Mar 2016 01:24:13 GMT","content-type":"application/json; charset=utf-8","transfer-encoding":"chunked","connection":"close","access-control-allow-origin":"*"}<br><code>{
"results": [
{
"user": {
"gender": "female",
"name": {
"title": "ms",
"first": "samara",
"last": "rocha"
},
"location": {
"street": "3166 rua pará",
"city": "cabo frio",
"state": "goiás",
"zip": 44101
},
"email": "samara.rocha@example.com",
"username": "smallmeercat214",
"password": "april",
"salt": "lJeLupaH",
"md5": "93d85105384f191849047f1f5f604ecb",
"sha1": "35acee66eea14c004f214819d11ab3bf92f07c8b",
"sha256": "f7c94aaef6fdfe1553aa107025b9df633af578af7a5635ebd7075785cf1390b0",
"registered": 1352011251,
"dob": 1131595230,
"phone": "(90) 5421-1840",
"cell": "(58) 9894-6336",
"picture": {
"large": "https://randomuser.me/api/portraits/women/67.jpg",
"medium": "https://randomuser.me/api/portraits/med/women/67.jpg",
"thumbnail": "https://randomuser.me/api/portraits/thumb/women/67.jpg"
}
}
}
],
"nationality": "BR",
"seed": "0b39f06d3acac76c01",
"version": "0.8"
}</code></body></html>
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**user:** [Pauloxt1](https://github.com/Pauloxt1)<br>
**autor:** Paulo Roberto
## Por que quando requisitamos ao nosso servidor de *Query String*, **com o Chrome**, ele executa 2 requisições, sendo a última "*vazia*"?
Porque uma requisição ele efetua com o GET que nós mandamos e outra ele manda tentando achar o favicon da página.
## Qual a DIFERENÇA entre o GET e o POST?
<b>GET:</b> Dados são transportados via URL, por ser assim só é suportado strings e há um limite de caracteres. É mais rápido que o POST pelo fato de ser mais simples.<br>
<b>POST:</b> Dados não são expóstos na URL e nesse caso pode ser transportado tanto dados do tipo string como binários não há limite de caracteres é um pouco mais lenta que o GET.
## Crie um Pokemon na nossa API com seu nome, depois modifique seu nome pelo seu User do Github.
```js
paulo@Paulo:~/workshop-be-mean/nodejs$ node create_pokemon.js
STATUS: 201
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"79","etag":"W/\"4f-FQst1JWQGV9Isx6b9QMehg\"","date":"Sat, 16 Jan 2016 17:37:40 GMT","via":"1.1 vegur"}
Dados finalizados {"__v":0,"name":"Paulo Roberto","type":"zeus","_id":"569a7fe41f61701100d42ac7"}
```
```js
paulo@Paulo:~/workshop-be-mean/nodejs$ node change_mon.js
STATUS: 202
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"108","etag":"W/\"6c-D2UU4v75j2T2occrW4VFWQ\"","date":"Sat, 16 Jan 2016 18:07:13 GMT","via":"1.1 vegur"}
Dados finalizados {"data":{"ok":1,"nModified":1,"n":1,"lastOp":"6240448465881530369","electionId":"565e25d106dca622271891c4"}}
```
## **Depois faça o DELETE**, criando o script para tal, colocando aqui a resposta.
```js
paulo@Paulo:~/workshop-be-mean/nodejs$ node delete_mon.js
STATUS: 204
HEADERS: {"server":"Cowboy","content-length":"0","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","date":"Sat, 16 Jan 2016 18:12:01 GMT","via":"1.1 vegur"}
Dados finalizados
```
## Escolha uma **API externa** e crie um script para fazer um GET nela **mostrando o resultado com HTML**.
Vamos usar a mesma API que usamos para inserir e deletar dados, com o seguinte script:
```js
// file: get-pokemons
'use strict';
const http = require('http');
var dados = '';
http.get({
hostname: 'webschool-io.herokuapp.com',
path: '/api/pokemons',
port:80,
agent: false
}, (response)=>{
console.log('STATUS: '+response.statusCode);
console.log('HEADERS: '+JSON.stringify(response.headers));
response.on('data', function(data){
dados += data;
});
response.on('end', function(){
newServer();
});
});
function newServer(){
http.createServer(function(request, response){
var pokemons = JSON.parse(dados);
for(var key in pokemons){
var pokemon = pokemons[key];
response.write('<b>ID:</b> '+pokemon._id+' <b>Nome:</b> '+pokemon.name+' <b>Tipo:</b> '+pokemon.type+'<br>');
}
response.end();
}).listen(3000, function(){
console.log('Aguardando conexões na porta 3000');
});
}
```
<b>Obtivemos o seguinte o resultado:</b><br>
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 03 - Exercício
**user:** https://github.com/paulosilva92
**autor:** Paulo Roberto da Silva
**date:** Sat Mar 05 2016 00:51:06 GMT-0300 (BRT)
## Por que quando requisitamos ao nosso servidor de *Query String*, com o Chrome, ele executa 2 requisições, sendo a última "vazia"?
Porque a segunda requisição se trata de uma requisição do favicon.ico do site, como o script que foi implementado na aula não da essa informação sobre o caminho do favicon.ico, ele retorna vazio.
## Qual a diferença entre GET e o POST
O GET é utilizado para requisitar informações do servidor, já o POST é utilizado para enviar informações ao servidor para criação de uma entidade.
## Crie um Pokemon na nossa API com seu nome, depois modifique seu nome pelo seu User do Github, colocando aqui a resposta de cada passo.
#### Criação do pokemon com meu nome
```js
'use strict';
const http = require('http');
const querystring = require('querystring');
const postData = querystring.stringify({
name: 'Paulo Roberto da Silva'
, type: 'Aluno'
});
const options = {
host: 'webschool-io.herokuapp.com'
, path: '/api/pokemons'
, method: 'POST'
, headers: {
'Content-Type': 'application/x-www-form-urlencoded'
, 'Content-Length': postData.length
}
};
function callback(res) {
console.log('STATUS: ' + res.statusCode);
console.log('HEADERS: ' + JSON.stringify(res.headers));
let data = '';
res.setEncoding('utf8');
res.on('data', (chunk) => {
data += chunk;
});
res.on('end', () => {
console.log('Dados finalizados: ', data)
})
}
const req = http.request(options, callback);
req.on('error', (e) => {
console.log('ERROOOO: ' + e.message);
});
req.write(postData);
req.end();
```
##### Reposta
```js
STATUS: 201
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"89","etag":"W/\"59-vUcwx+2vIgWhwIrlPOqnug\"","date":"Tue, 01 Mar 2016 00:38:04 GMT","via":"1.1 vegur"}
Dados finalizados: {"__v":0,"name":"Paulo Roberto da Silva","type":"Aluno","_id":"56d4e46cd537501100aa9722"}
```
#### Modificando o nome para meu user do Github
```js
'use strict';
const http = require('http');
const querystring = require('querystring');
const postData = querystring.stringify({
name: 'paulosilva92'
});
const options = {
host: 'webschool-io.herokuapp.com'
, path: '/api/pokemons/56d4e46cd537501100aa9722'
, method: 'PUT'
, headers: {
'Content-Type': 'application/x-www-form-urlencoded'
, 'Content-Length': postData.length
}
};
function callback(res) {
console.log('STATUS: ' + res.statusCode);
console.log('HEADERS: ' + JSON.stringify(res.headers));
let data = '';
res.setEncoding('utf8');
res.on('data', (chunk) => {
data += chunk;
});
res.on('end', () => {
console.log('Dados finalizados: ', data)
})
}
const req = http.request(options, callback);
req.on('error', (e) => {
console.log('ERROOOO: ' + e.message);
});
req.write(postData);
req.end();
```
##### resposta
```js
➜ aulas git:(master) ✗ node http-request-put.js
STATUS: 202
HEADERS: {"server":"Cowboy","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","content-type":"application/json; charset=utf-8","content-length":"108","etag":"W/\"6c-cOYquFHX6hzfF+eAuo8bCw\"","date":"Tue, 01 Mar 2016 00:39:02 GMT","via":"1.1 vegur"}
Dados finalizados: {"data":{"ok":1,"nModified":1,"n":1,"lastOp":"6256877183940165633","electionId":"565e25d106dca622271891c4"}}
```
## Depois faça o DELETE, criando o script para tal e colocando aqui a resposta.
```js
'use strict';
const http = require('http');
const querystring = require('querystring');
const postData = querystring.stringify({
name: 'paulosilva92'
});
const options = {
host: 'webschool-io.herokuapp.com'
, path: '/api/pokemons/56d4e46cd537501100aa9722'
, method: 'DELETE'
, headers: {
'Content-Type': 'application/x-www-form-urlencoded'
, 'Content-Length': postData.length
}
};
function callback(res) {
console.log('STATUS: ' + res.statusCode);
console.log('HEADERS: ' + JSON.stringify(res.headers));
let data = '';
res.setEncoding('utf8');
res.on('data', (chunk) => {
data += chunk;
});
res.on('end', () => {
console.log('Dados finalizados: ', data)
})
}
const req = http.request(options, callback);
req.on('error', (e) => {
console.log('ERROOOO: ' + e.message);
});
//req.write(postData);
req.end();
```
##### reposta
```js
➜ aulas git:(master) ✗ node http-request-delete.js
STATUS: 204
HEADERS: {"server":"Cowboy","content-length":"0","connection":"close","x-powered-by":"Express","access-control-allow-origin":"*","date":"Wed, 02 Mar 2016 16:59:03 GMT","via":"1.1 vegur"}
Dados finalizados:
```
## Escolha uma API externa e crie um script para fazer um GET nela mostrando o resultado com HTML.
```js
'use strict';
const http = require('http');
var RESP = {
name: 'resposta'
};
http.get({
hostname : 'pokeapi.co',
path: '/api/v2/language/5/',
},(response) => {
let body = "";
console.log('STATUS:'+ response.statusCode);
console.log(response.headers);
response.on('data', data=>{
body += data;
});
response.on('end', function(){
RESP.result = JSON.parse(body).name;
});
});
http.createServer((request, response)=>{
response.writeHead(200, {'Content-Type': 'text/html'});
response.write('<h1>'+RESP.result+'<h1>');
response.end();
}).listen(3000, function(){
console.log('rodando nas porta 3000');
});
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 06 - Exercícios
**User:** [matheusjkweber](https://github.com/matheusjkweber)
**Autor:** Matheus Jose Krumenauer Weber
**Date:** 1457207231956
## Crie um Schema com cada tipo explicado, inserindo tanto um objeto correto, como um objeto que desencadeie erros de validação padrão, criar especificamente:
### Com erros:
```js
require('./config.js');
const mongoose = require('mongoose');
const Schema = mongoose.Schema;
const _schema = {
name: {type: String, match: /^S/, minlength: 3, maxlength:10},
picture: Buffer,
description: String,
type: {type: String, maxlength: 100, minlength: 5},
attack: { type: Number, min: 0, max: 100 },
defense: { type: Number, min: 0, max: 100 },
height: { type: Number, min: 0, max: 100 },
create_at: {type: Date, default: Date.now},
gender: {type:String, enum: ['male','female']},
atacks: Schema.Types.Mixed,
other_types: [String],
active: Boolean
};
const pokemonSchema = new Schema(_schema);
console.log("Schema created.");
const buf3 = new Buffer('test');
const attacks = {name: "Thundershock", power: 50}
const pokemonModel ={
name: "pi",
picture: buf3,
description: "lalala",
type: "Fire",
attak: 120,
defense: -20,
heigth: 120,
gender: "none",
atacks: attacks,
other_type: ["leaf"],
active: 1
}
var model = mongoose.model('pokemons', pokemonSchema);
var poke = new model(pokemonModel);
poke.save(function (err, data) {
if (err) return console.log('ERRO: ', err);
console.log('Inseriu: ', data)
})
module.exports = pokemonSchema;
```
```
Schema created.
ERRO: { [ValidationError: pokemons validation failed]
message: 'pokemons validation failed',
name: 'ValidationError',
errors:
{ gender:
{ [ValidatorError: `none` is not a valid enum value for path `gender`.]
properties: [Object],
message: '`none` is not a valid enum value for path `gender`.',
name: 'ValidatorError',
kind: 'enum',
path: 'gender',
value: 'none' },
defense:
{ [ValidatorError: Path `defense` (-20) is less than minimum allowed value (0).]
properties: [Object],
message: 'Path `defense` (-20) is less than minimum allowed value (0).',
name: 'ValidatorError',
kind: 'min',
path: 'defense',
value: -20 },
type:
{ [ValidatorError: Path `type` (`Fire`) is shorter than the minimum allowed length (5).]
properties: [Object],
message: 'Path `type` (`Fire`) is shorter than the minimum allowed length (5).',
name: 'ValidatorError',
kind: 'minlength',
path: 'type',
value: 'Fire' },
name:
{ [ValidatorError: Path `name` is invalid (pi).]
properties: [Object],
message: 'Path `name` is invalid (pi).',
name: 'ValidatorError',
kind: 'regexp',
path: 'name',
value: 'pi' } } }
Mongoose default connection connected to mongodb://localhost/be-mean-pokemons
Mongoose default connection is open
```
### Sem erros de validação:
```js
require('./config.js');
const mongoose = require('mongoose');
const Schema = mongoose.Schema;
const _schema = {
name: {type: String, minlength: 3, maxlength:20},
picture: Buffer,
description: String,
type: {type: String, maxlength: 100, minlength: 3},
attack: { type: Number, min: 0, max: 100 },
defense: { type: Number, min: 0, max: 100 },
height: { type: Number, min: 0, max: 100 },
create_at: {type: Date, default: Date.now},
gender: {type:String, enum: ['male','female']},
atacks: Schema.Types.Mixed,
other_types: [String],
active: Boolean
};
const pokemonSchema = new Schema(_schema);
console.log("Schema created.");
const buf3 = new Buffer('test');
const attacks = {name: "Thundershock", power: 50}
const pokemonModel ={
name: "charmanders",
picture: buf3,
description: "Pokemon de fogo lindao.",
type: "Fire",
attak: 17,
defense: 8,
heigth: 5,
gender: "male",
atacks: attacks,
other_type: ["leaf"],
active: 1
}
var model = mongoose.model('pokemons', pokemonSchema);
var poke = new model(pokemonModel);
poke.save(function (err, data) {
if (err) return console.log('ERRO: ', err);
console.log('Inseriu: ', data)
})
module.exports = pokemonSchema;
```
```
Schema created.
Mongoose default connection connected to mongodb://localhost/be-mean-pokemons
Mongoose default connection is open
Inseriu: { create_at: Sat Mar 05 2016 17:17:20 GMT-0300 (BRT),
other_types: [],
_id: 56db3ed040db47d213d901eb,
active: true,
atacks: { name: 'Thundershock', power: 50 },
gender: 'male',
defense: 8,
type: 'Fire',
description: 'Pokemon de fogo lindao.',
picture:
Binary {
_bsontype: 'Binary',
sub_type: 0,
position: 4,
buffer: <Buffer 74 65 73 74> },
name: 'charmanders',
__v: 0 }
```
## Cadastre 3 pokemons de uma só vez. (pesquisar).
```js
require('./config.js');
const mongoose = require('mongoose');
const Schema = mongoose.Schema;
const _schema = {
name: {type: String, minlength: 3, maxlength:20},
picture: Buffer,
description: String,
type: {type: String, maxlength: 100, minlength: 3},
attack: { type: Number, min: 0, max: 100 },
defense: { type: Number, min: 0, max: 100 },
height: { type: Number, min: 0, max: 100 },
create_at: {type: Date, default: Date.now},
gender: {type:String, enum: ['male','female']},
atacks: Schema.Types.Mixed,
other_types: [String],
active: Boolean
};
const pokemonSchema = new Schema(_schema);
console.log("Schema created.");
const buf3 = new Buffer('test');
const attacks = {name: "Thundershock", power: 50}
const pokemonModel =[ {
name: "Pikachu",
picture: buf3,
description: "Pokemon eletrico lindao.",
type: "Eletric",
attak: 20,
defense: 5,
heigth: 7,
gender: "female",
atacks: attacks,
other_type: ["rat"],
active: 1
}, {
name: "Raichu",
picture: buf3,
description: "Pokemon eletrico lindao.",
type: "Eletric",
attak: 37,
defense: 22,
heigth: 15,
gender: "female",
atacks: attacks,
other_type: ["rat"],
active: 1
}, {
name: "Pichu",
picture: buf3,
description: "Pokemon eletrico lindao.",
type: "Eletric",
attak: 12,
defense: 5,
heigth: 3,
gender: "female",
atacks: attacks,
other_type: ["rat"],
active: 1
}]
var model = mongoose.model('pokemons', pokemonSchema);
pokemonModel.forEach(function(data){
console.log(data);
var poke = new model(data);
poke.save(function (err, data) {
if (err) return console.log('ERRO: ', err);
console.log('Inseriu: ', data)
})
});
/*var poke = new model(pokemonModel);
poke.save(function (err, data) {
if (err) return console.log('ERRO: ', err);
console.log('Inseriu: ', data)
})*/
module.exports = pokemonSchema;
```
```
Mongoose default connection connected to mongodb://localhost/be-mean-pokemons
Mongoose default connection is open
Inseriu: { create_at: Sat Mar 05 2016 17:22:16 GMT-0300 (BRT),
other_types: [],
_id: 56db3ff878d92438145403d7,
active: true,
atacks: { name: 'Thundershock', power: 50 },
gender: 'female',
defense: 5,
type: 'Eletric',
description: 'Pokemon eletrico lindao.',
picture:
Binary {
_bsontype: 'Binary',
sub_type: 0,
position: 4,
buffer: <Buffer 74 65 73 74> },
name: 'Pikachu',
__v: 0 }
Inseriu: { create_at: Sat Mar 05 2016 17:22:16 GMT-0300 (BRT),
other_types: [],
_id: 56db3ff878d92438145403d8,
active: true,
atacks: { name: 'Thundershock', power: 50 },
gender: 'female',
defense: 22,
type: 'Eletric',
description: 'Pokemon eletrico lindao.',
picture:
Binary {
_bsontype: 'Binary',
sub_type: 0,
position: 4,
buffer: <Buffer 74 65 73 74> },
name: 'Raichu',
__v: 0 }
Inseriu: { create_at: Sat Mar 05 2016 17:22:16 GMT-0300 (BRT),
other_types: [],
_id: 56db3ff878d92438145403d9,
active: true,
atacks: { name: 'Thundershock', power: 50 },
gender: 'female',
defense: 5,
type: 'Eletric',
description: 'Pokemon eletrico lindao.',
picture:
Binary {
_bsontype: 'Binary',
sub_type: 0,
position: 4,
buffer: <Buffer 74 65 73 74> },
name: 'Pichu',
__v: 0 }
```
## Busque todos os Pokemons com attack > 50 e height > 0.5:
```js
require('./config.js');
const mongoose = require('mongoose');
const Schema = mongoose.Schema;
const _schema = {
name: {type: String, minlength: 3, maxlength:20},
picture: Buffer,
description: String,
type: {type: String, maxlength: 100, minlength: 3},
attack: { type: Number, min: 0, max: 100 },
defense: { type: Number, min: 0, max: 100 },
height: { type: Number, min: 0, max: 100 },
create_at: {type: Date, default: Date.now},
gender: {type:String, enum: ['male','female']},
atacks: Schema.Types.Mixed,
other_types: [String],
active: Boolean
};
const pokemonSchema = new Schema(_schema);
var model = mongoose.model('pokemons', pokemonSchema);
const query = {attack: {$gt:50}, height: {$gt: 0.5}};
model.find(query, function (err, data) {
if (err) return console.log('ERRO: ', err);
console.log('Inseriu: ', data)
})
module.exports = pokemonSchema;
```
```
Mongoose default connection connected to mongodb://localhost/be-mean-pokemons
Mongoose default connection is open
Inseriu: [ { create_at: Sat Mar 05 2016 17:25:32 GMT-0300 (BRT),
other_types: [],
moves: [ [Object] ],
height: 5.2,
attack: 100,
type: 'fire',
description: 'Salamandra de fogo evoluida',
name: 'Charmeleon',
_id: 56478345771dc8af7806b25f },
{ create_at: Sat Mar 05 2016 17:25:32 GMT-0300 (BRT),
other_types: [],
moves: [ [Object] ],
height: 17,
attack: 160,
type: 'fire',
description: 'Salamandra de fogo evoluida suprema',
name: 'Charizard',
_id: 56478346771dc8af7806b260 },
{ create_at: Sat Mar 05 2016 17:25:32 GMT-0300 (BRT),
other_types: [],
moves: [ [Object] ],
height: 5,
attack: 130,
type: 'psychic',
description: 'O senhor supremo do mundo pokemon',
name: 'Mewtwo',
_id: 56478348771dc8af7806b261 },
{ create_at: Sat Mar 05 2016 17:25:32 GMT-0300 (BRT),
other_types: [],
moves: [ 'patada', 'endurecer', [Object] ],
height: 0.6,
attack: 52,
type: 'fogo',
description: 'Esse é o cão chupando manga de fofinho',
name: 'Charmander',
_id: 564d10f258ed05ea2e341137 } ]
```
## Altere, inserindo, o Pokemon Nerdmon com attack igual a 49 e com os valores dos outros campos a sua escolha.
```js
require('./config.js');
const mongoose = require('mongoose');
const Schema = mongoose.Schema;
const _schema = {
name: {type: String, minlength: 3, maxlength:20},
picture: Buffer,
description: String,
type: {type: String, maxlength: 100, minlength: 3},
attack: { type: Number, min: 0, max: 100 },
defense: { type: Number, min: 0, max: 100 },
height: { type: Number, min: 0, max: 100 },
create_at: {type: Date, default: Date.now},
gender: {type:String, enum: ['male','female']},
atacks: Schema.Types.Mixed,
other_types: [String],
active: Boolean
};
const pokemonSchema = new Schema(_schema);
console.log("Schema created.");
const buf3 = new Buffer('test');
const attacks = {name: "Thundershock", power: 50}
const pokemonModel ={
name: "Nerdmon",
picture: buf3,
description: "Pokemon de fogo lindao.",
type: "Fire",
attak: 49 ,
defense: 8,
heigth: 5,
gender: "male",
atacks: attacks,
other_type: ["leaf"],
active: 1
}
var model = mongoose.model('pokemons', pokemonSchema);
const query = {name: /Nerdmon/i}
const mod = {$setOnInsert: pokemonModel}
const options = {upsert: true}
model.update(query, mod, options, function (err, data) {
if (err) return console.log('ERRO: ', err);
console.log('Alterou: ', data)
})
module.exports = pokemonSchema;
```
```
matheus@Math:~/Desktop/Desenvolvimento/workshop-be-mean/nodejs/class6$ node exercicio4.js
Schema created.
Mongoose default connection connected to mongodb://localhost/be-mean-pokemons
Mongoose default connection is open
Alterou: { ok: 1,
nModified: 0,
n: 1,
upserted: [ { index: 0, _id: 56db4181ca92b6ac012b6cf7 } ] }
```
## Remova todos os Pokemons com attack acima de 50.
```js
require('./config.js');
const mongoose = require('mongoose');
const Schema = mongoose.Schema;
const _schema = {
name: {type: String, minlength: 3, maxlength:20},
picture: Buffer,
description: String,
type: {type: String, maxlength: 100, minlength: 3},
attack: { type: Number, min: 0, max: 100 },
defense: { type: Number, min: 0, max: 100 },
height: { type: Number, min: 0, max: 100 },
create_at: {type: Date, default: Date.now},
gender: {type:String, enum: ['male','female']},
atacks: Schema.Types.Mixed,
other_types: [String],
active: Boolean
};
const pokemonSchema = new Schema(_schema);
var model = mongoose.model('pokemons', pokemonSchema);
const query = {atack: {$gt: 50}}
model.remove(query, function (err, data) {
if (err) return console.log('ERRO: ', err);
console.log('Removeu: ', data)
})
module.exports = pokemonSchema;
```
```
Removeu: { result: { ok: 1, n: 0 },
connection:
EventEmitter {
domain: null,
_events:
{ close: [Object],
error: [Object],
timeout: [Object],
parseError: [Object],
connect: [Function] },
_eventsCount: 5,
_maxListeners: undefined,
options:
{ socketOptions: {},
auto_reconnect: true,
host: 'localhost',
port: 27017,
cursorFactory: [Object],
reconnect: true,
emitError: true,
size: 5,
disconnectHandler: [Object],
bson: {},
messageHandler: [Function],
wireProtocolHandler: {} },
id: 0,
logger: { className: 'Connection' },
bson: {},
tag: undefined,
messageHandler: [Function],
maxBsonMessageSize: 67108864,
port: 27017,
host: 'localhost',
keepAlive: true,
keepAliveInitialDelay: 0,
noDelay: true,
connectionTimeout: 0,
socketTimeout: 0,
destroyed: false,
domainSocket: false,
singleBufferSerializtion: true,
serializationFunction: 'toBinUnified',
ca: null,
cert: null,
key: null,
passphrase: null,
ssl: false,
rejectUnauthorized: false,
checkServerIdentity: true,
responseOptions: { promoteLongs: true },
flushing: false,
queue: [],
connection:
Socket {
_connecting: false,
_hadError: false,
_handle: [Object],
_parent: null,
_host: 'localhost',
_readableState: [Object],
readable: true,
domain: null,
_events: [Object],
_eventsCount: 8,
_maxListeners: undefined,
_writableState: [Object],
writable: true,
allowHalfOpen: false,
destroyed: false,
bytesRead: 250,
_bytesDispatched: 229,
_sockname: null,
_pendingData: null,
_pendingEncoding: '',
server: null,
_server: null,
_idleNext: null,
_idlePrev: null,
_idleTimeout: -1,
read: [Function],
_consuming: true },
writeStream: null,
hashedName: '29bafad3b32b11dc7ce934204952515ea5984b3c',
buffer: null,
sizeOfMessage: 0,
bytesRead: 0,
stubBuffer: null } }
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 06 - Exercício
**user:** [Pauloxt1](https://github.com/Pauloxt1)
**autor:** Paulo Roberto
## Crie um Schema com cada tipo explicado, inserindo tanto um objeto correto, como um objeto que desencadeie erros de validação padrão, criar especificamente:
* 1.1. para String: `enum`, `match`, `maxlength` e `minlength`
* 1.2. para Number: `max` e `min`
<b>Objeto correto:</b>
```js
const fs = require('fs');
const mongoose = require('mongoose');
const Schema = mongoose.Schema;
var enu = {
values: ['Paulo'],
message: 'Ocorreu um erro documento `{PATH}` com valor `{VALUE}` do tipo `{TYPE}`'
}
// user Schema
const _schema = {
login:{type:String, minlength:2, maxlength:10, match: /^\w/, enum: enu},
active: Boolean,
date_register:Date,
profile_image: {data: Buffer, contentType: String},
friends:[{type: Schema.Types.ObjectId, ref: 'users'}],
profile_tags: [String],
age: {type:Number, max:100, min:12},
favorites: Schema.Types.Mixed
}
const userSchema = new Schema(_schema);
const userModel = mongoose.model('users', userSchema);
const readImg = fs.readFileSync('default.jpg');
const user = new userModel({
login:'Paulo',
active:1,
date_register: Date.now(),
friends:["56a5953b1416d13a8e98715b"],
profile_image:{data:readImg, contentType:'image/jpeg'},
profile_tags:['batata', 'tag1'],
age:16,
favorites:[{id:null, data:Date.now()}]
});
user.save(function(err, result){
if(err) console.log(err);
console.log(result);
});
```
```shell
paulo@Paulo:~/workshop-be-mean/nodejs/exercicio6$ node app.js
Mongoose default connection connected to mongodb://localhost/exercicio6
Mongoose default connection is open
{ profile_image:
{ contentType: 'image/jpeg',
data:
Binary {
_bsontype: 'Binary',
sub_type: 0,
position: 1984,
buffer: <Buffer ff d8 ff e0 00 10 4a 46 49 46 00 01 01 00 00 01 00 01 00 00 ff db 00 84 00 09 06 07 12 10 10 15 0f 10 10 10 16 15 17 16 18 18 18 11 15 15 15 17 16 16 ... > } },
friends: [ 56a5953b1416d13a8e98715b ],
profile_tags: [ 'batata', 'tag1' ],
_id: 56a5965c09badc7e2bd93acc,
favorites: [ { id: null, data: 1453692508444 } ],
age: 16,
date_register: Mon Jan 25 2016 01:28:28 GMT-0200 (BRST),
active: true,
login: 'Paulo',
__v: 0 }
```
<b>Objeto que não está de acordo com o Schema:</b>
```js
const user = new userModel({
login:'teste',
active:'1',
date_register: '17/02/1999',
friends:'joão',
profile_image:10,
profile_tags:'js mongoose webschool',
age:'16',
favorites:[{id:null, data:Date.now()}]
});
```
```shell
{ [ValidationError: users validation failed]
message: 'users validation failed',
name: 'ValidationError',
errors:
{ friends:
{ [CastError: Cast to Array failed for value "joão" at path "friends"]
message: 'Cast to Array failed for value "joão" at path "friends"',
name: 'CastError',
kind: 'Array',
value: 'joão',
path: 'friends',
reason: undefined },
date_register:
{ [CastError: Cast to Date failed for value "17/02/1999" at path "date_register"]
message: 'Cast to Date failed for value "17/02/1999" at path "date_register"',
name: 'CastError',
kind: 'Date',
value: '17/02/1999',
path: 'date_register',
reason: undefined },
login:
{ [ValidatorError: Ocorreu um erro documento `login` com valor `teste` do tipo `enum`]
properties: [Object],
message: 'Ocorreu um erro documento `login` com valor `teste` do tipo `enum`',
name: 'ValidatorError',
kind: 'enum',
path: 'login',
value: 'teste' } } }
```
## Cadastre 3 pokemons **de uma só vez**:
```js
const mongoose = require('mongoose');
const Schema = mongoose.Schema;
// criação do Schema
const _schema = {
name: String,
description: String,
type: String,
attack: Number,
defense: Number,
height: Number,
crated_at:{type:Date, default: Date.now}
};
const pokemonSchema = new Schema(_schema);
const data = [{name:'Pokemon1', type:'batata', attack:-1, defense:-10, height:6969},
{name:'Pokemon2', type:'batata', attack:-1, defense:-10, height:6969},
{name:'Pokemon3', type:'batata', attack:-1, defense:-10, height:6969}];
var Model = mongoose.model('pokemons', pokemonSchema);
data.forEach(function(data){
var poke = new Model(data);
poke.save(function(err, data){
if(err) console.log('Error: ', err);
console.log('Inseriu: ', data);
});
});
```
## Busque **todos** os Pokemons com `attack > 50` e `height > 0.5`:
```js
const mongoose = require('mongoose');
const Schema = mongoose.Schema;
// criação do Schema
const _schema = {
name: String,
description: String,
type: String,
attack: Number,
defense: Number,
height: Number,
crated_at:{type:Date, default: Date.now}
};
const pokemonSchema = new Schema(_schema);
const PokemonModel = mongoose.model('pokemons', pokemonSchema);
const query = {attack:{$gt:50}, height:{$gt:0.5}};
PokemonModel.find(query, function (err, data) {
if (err) return console.log('ERRO: ', err);
return console.log('Buscou:', data);
});
```
```shell
Mongoose default connection connected to mongodb://localhost/exercicio6
Mongoose default connection is open
Buscou: []
```
## Altere, **inserindo**, o Pokemon `Nerdmon` com `attack` igual a 49 e com os valores dos outros campos a sua escolha.
```js
const mongoose = require('mongoose');
const Schema = mongoose.Schema;
// criação do Schema
const _schema = {
name: String,
description: String,
type: String,
attack: Number,
defense: Number,
height: Number
};
const PokemonSchema = new Schema(_schema);
const Pokemon = mongoose.model('pokemons', PokemonSchema);
const query = {name: /Nerdmon/i}
const mod = {$setOnInsert: {name: 'Nerdmon', description: 'Pokemon badass', type:'nerd', attack:8000, defense:8000, height:100}}
const options = {upsert: true}
Pokemon.update(query, mod, options, function (err, data) {
if (err) return console.log('ERRO: ', err);
return console.log('Alterou:', data);
});
```
```shell
paulo@Paulo:~/workshop-be-mean/nodejs/exercicio6$ node app.js
Mongoose default connection connected to mongodb://localhost/exercicio6
Mongoose default connection is open
Alterou: { ok: 1,
nModified: 0,
n: 1,
upserted: [ { index: 0, _id: 56a5790484be28b34911322c } ] }
```
## Remova **todos** os Pokemons com `attack` **acima de 50**.
```js
const mongoose = require('mongoose');
const Schema = mongoose.Schema;
// criação do Schema
const _schema = {
name: String,
description: String,
type: String,
attack: Number,
defense: Number,
height: Number,
crated_at:{type:Date, default: Date.now}
};
const pokemonSchema = new Schema(_schema);
const PokemonModel = mongoose.model('pokemons', pokemonSchema);
const query = {attack:{$gt:50}};
PokemonModel.remove(query, function (err, data) {
if (err) return console.log('ERRO: ', err);
return console.log('Removeu:', data);
});
```
```shell
paulo@Paulo:~/workshop-be-mean/nodejs/exercicio6$ node app.js
Mongoose default connection connected to mongodb://localhost/exercicio6
Mongoose default connection is open
Removeu: { result: { ok: 1, n: 462 },
connection:
EventEmitter {
domain: null,
_events:
{ close: [Object],
error: [Object],
timeout: [Object],
parseError: [Object],
connect: [Function] },
_eventsCount: 5,
_maxListeners: undefined,
options:
{ socketOptions: {},
auto_reconnect: true,
host: 'localhost',
port: 27017,
cursorFactory: [Object],
reconnect: true,
emitError: true,
size: 5,
disconnectHandler: [Object],
bson: {},
messageHandler: [Function],
wireProtocolHandler: [Object] },
id: 2,
logger: { className: 'Connection' },
bson: {},
tag: undefined,
messageHandler: [Function],
maxBsonMessageSize: 67108864,
port: 27017,
host: 'localhost',
keepAlive: true,
keepAliveInitialDelay: 0,
noDelay: true,
connectionTimeout: 0,
socketTimeout: 0,
destroyed: false,
domainSocket: false,
singleBufferSerializtion: true,
serializationFunction: 'toBinUnified',
ca: null,
cert: null,
key: null,
passphrase: null,
ssl: false,
rejectUnauthorized: false,
checkServerIdentity: true,
responseOptions: { promoteLongs: true },
flushing: false,
queue: [],
connection:
Socket {
_connecting: false,
_hadError: false,
_handle: [Object],
_parent: null,
_host: 'localhost',
_readableState: [Object],
readable: true,
domain: null,
_events: [Object],
_eventsCount: 8,
_maxListeners: undefined,
_writableState: [Object],
writable: true,
allowHalfOpen: false,
destroyed: false,
bytesRead: 56,
_bytesDispatched: 169,
_sockname: null,
_pendingData: null,
_pendingEncoding: '',
_idleNext: null,
_idlePrev: null,
_idleTimeout: -1,
read: [Function],
_consuming: true },
writeStream: null,
buffer: null,
sizeOfMessage: 0,
bytesRead: 0,
stubBuffer: null } }
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 06 - Exercício
**User:** [Cerezini](https://github.com/Cerezini)
**Autor:** Mateus Cerezini Gomes
## Crie um Schema com cada tipo explicado, inserindo tanto um objeto correto, como um objeto que desencadeie erros de validação padrão, criar especificamente:
* 1.1. para String: `enum`, `match`, `maxlength` e `minlength`
* 1.2. para Number: `max` e `min`
```js
'use strict';
const mongoose = require('mongoose');
const Schema = mongoose.Schema;
const pokemonSchema = new Schema({
name: {type: String, match: /^(\D)*$/g},
password: {type: String, minlength: 8},
description: {type: String, maxlength: 20},
type: {type: String, enum: ['Water', 'Fire', 'Stone', 'Bug']},
attack: {type: Number, min: 30},
defense: {type: Number, max: 70},
hasSpecial: {type: Boolean, required: true},
skills: [String],
created_at: {type: Date, default: Date.now},
relatedTo: [{type: Schema.Types.ObjectId, ref: 'pokemons'}]
});
const PokemonModel = mongoose.model('pokemons', pokemonSchema);
let poke = new PokemonModel({
name: 'PotatoMon',
password: '12345566',
description: 'A good pokemon',
type: 'Stone',
attack: 100,
defense: 45,
hasSpecial: true,
skills: ['throw potatos','potato soup', 'calzone']
});
poke.validate((err, data) => {
if (err) return console.log(err);
console.log('Objeto válido');
});
```
Resultado:
```bash
Objeto válido
```
Mudando o objeto `poke`, temos:
```js
let poke = new PokemonModel({
name: '666PotatoMon',
password: '1111',
description: 'A good pokemon that likes to throw potatos in all of its friends, bla bla bla bla',
type: 'Vegetable',
attack: 10,
defense: 100,
skills: true
});
```
Resultado:
```js
{ [ValidationError: pokemons validation failed]
message: 'pokemons validation failed',
name: 'ValidationError',
errors:
{ hasSpecial:
{ [ValidatorError: Path `hasSpecial` is required.]
message: 'Path `hasSpecial` is required.',
name: 'ValidatorError',
properties: [Object],
kind: 'required',
path: 'hasSpecial',
value: undefined },
defense:
{ [ValidatorError: Path `defense` (100) is more than maximum allowed value (70).]
message: 'Path `defense` (100) is more than maximum allowed value (70).',
name: 'ValidatorError',
properties: [Object],
kind: 'max',
path: 'defense',
value: 100 },
attack:
{ [ValidatorError: Path `attack` (10) is less than minimum allowed value (30).]
message: 'Path `attack` (10) is less than minimum allowed value (30).',
name: 'ValidatorError',
properties: [Object],
kind: 'min',
path: 'attack',
value: 10 },
type:
{ [ValidatorError: `Vegetable` is not a valid enum value for path `type`.]
message: '`Vegetable` is not a valid enum value for path `type`.',
name: 'ValidatorError',
properties: [Object],
kind: 'enum',
path: 'type',
value: 'Vegetable' },
description:
{ [ValidatorError: Path `description` (`A good pokemon that likes to throw potatos in all of its friends, bla bla bla bla`) is longer than the maximum allowed length (20).]
message: 'Path `description` (`A good pokemon that likes to throw potatos in all of its friends, bla bla bla bla`) is longer than the maximum allowed length (20).',
name: 'ValidatorError',
properties: [Object],
kind: 'maxlength',
path: 'description',
value: 'A good pokemon that likes to throw potatos in all of its friends, bla bla bla bla' },
password:
{ [ValidatorError: Path `password` (`1111`) is shorter than the minimum allowed length (8).]
message: 'Path `password` (`1111`) is shorter than the minimum allowed length (8).',
name: 'ValidatorError',
properties: [Object],
kind: 'minlength',
path: 'password',
value: '1111' },
name:
{ [ValidatorError: Path `name` is invalid (666PotatoMon).]
message: 'Path `name` is invalid (666PotatoMon).',
name: 'ValidatorError',
properties: [Object],
kind: 'regexp',
path: 'name',
value: '666PotatoMon' }
}
}
```
## Cadastre 3 pokemons **de uma só vez**:
A mesma organização de códigos da aula será utilizada, com os arquivos `app.js` e `config.js`. O código a seguir com a criação do `PokemonModel` será omitido nas atividades seguintes porque não será alterado.
```js
'use strict';
const mongoose = require('mongoose');
const Schema = mongoose.Schema;
const pokemonSchema = new Schema({
name: String,
attack: Number,
defense: Number,
hp: Number,
speed: Number,
height: String,
types: [String],
created: {type: Date, default: Date.now}
});
const PokemonModel = mongoose.model('pokemons', pokemonSchema);
let pokes = [
new PokemonModel({
name: 'poke1',
attack: 50,
defense: 50,
hp: 200,
speed: 30,
height: '1',
types: ['electric', 'flyer']
}),
new PokemonModel({
name: 'poke2',
attack: 100,
defense: 30,
hp: 100,
speed: 50,
height: '0.5',
types: ['fire']
}),
new PokemonModel({
name: 'poke3',
attack: 47,
defense: 33,
hp: 50,
speed: 30,
height: '3',
types: ['insect']
}),
];
PokemonModel.create(pokes, (err, data) => {
if (err) return console.log('ERROR: ', err);
console.log('INSERTED: ', data);
});
module.export = PokemonModel;
```
Resultado:
```shell
Mongoose default connection open to mongodb://localhost/be-mean-instagram
Mongoose default connection is open
INSERTED: [ { types: [ 'electric', 'flyer' ],
created: Sat Mar 26 2016 21:35:32 GMT-0300 (BRT),
name: 'poke1',
attack: 50,
defense: 50,
hp: 200,
speed: 30,
height: '1',
_id: 56f72ad41be3caff5458b78e,
__v: 0 },
{ types: [ 'fire' ],
created: Sat Mar 26 2016 21:35:32 GMT-0300 (BRT),
name: 'poke2',
attack: 100,
defense: 30,
hp: 100,
speed: 50,
height: '0.5',
_id: 56f72ad41be3caff5458b78f,
__v: 0 },
{ types: [ 'insect' ],
created: Sat Mar 26 2016 21:35:32 GMT-0300 (BRT),
name: 'poke3',
attack: 47,
defense: 33,
hp: 50,
speed: 30,
height: '3',
_id: 56f72ad41be3caff5458b790,
__v: 0 } ]
```
## Busque **todos** os Pokemons com `attack > 50` e `height > 0.5`:
```js
let query = {$and: [{attack: {$gt: 50}}, {height: {$gt: 0.5}}]};
PokemonModel.find(query, (err, data) => {
if (err) return console.log('ERROR: ', err);
console.log('RETURNED: ', data.length);
});
module.export = PokemonModel;
```
Uma parte do resultado, pois o conjunto resultado contém 423 pokemons:
```shell
[{ types: [ 'ground', 'rock' ],
created: Sun Nov 03 2013 13:05:42 GMT-0200 (BRST),
speed: 40,
name: 'Rhyperior',
hp: 115,
height: '24',
defense: 130,
attack: 140,
_id: 564b1dcb25337263280d059a },
{ types: [ 'fighting' ],
created: Sun Nov 03 2013 13:05:42 GMT-0200 (BRST),
speed: 45,
name: 'Conkeldurr',
hp: 105,
height: '14',
defense: 95,
attack: 140,
_id: 564b1dcf25337263280d05b9 },
{ types: [ 'flying', 'rock' ],
created: Sun Nov 03 2013 13:05:42 GMT-0200 (BRST),
speed: 110,
name: 'Archeops',
hp: 75,
height: '14',
defense: 65,
attack: 140,
_id: 564b1de225337263280d0684 },
{ types: [ 'ground' ],
created: Sun Nov 03 2013 13:05:41 GMT-0200 (BRST),
speed: 90,
name: 'Groudon',
hp: 100,
height: '35',
defense: 140,
attack: 150,
_id: 564b1dbf25337263280d052a },
{ types: [ 'flying', 'dragon' ],
created: Sun Nov 03 2013 13:05:41 GMT-0200 (BRST),
speed: 95,
name: 'Rayquaza',
hp: 105,
height: '70',
defense: 90,
attack: 150,
_id: 564b1dc625337263280d056f },
{ types: [ 'normal' ],
created: Sun Nov 03 2013 13:05:41 GMT-0200 (BRST),
speed: 100,
name: 'Slaking',
hp: 150,
height: '20',
defense: 100,
attack: 160,
_id: 564b1dce25337263280d05b6 },
{ types: [ 'normal' ],
created: Sun Nov 03 2013 13:05:42 GMT-0200 (BRST),
speed: 100,
name: 'Regigigas',
hp: 110,
height: '37',
defense: 110,
attack: 160,
_id: 564b1de125337263280d0677 },
{ types: [ 'rock' ],
created: Sun Nov 03 2013 13:05:42 GMT-0200 (BRST),
speed: 58,
name: 'Rampardos',
hp: 97,
height: '16',
defense: 60,
attack: 165,
_id: 564b1dc125337263280d0540 }
]
```
## Altere, **inserindo**, o Pokemon `Nerdmon` com `attack` igual a 49 e com os valores dos outros campos a sua escolha.
```js
let query = {name: 'Nerdmon'};
let options = {upsert: true};
let mod = {
name: 'Nerdmon',
attack: 49,
defense: 45,
hp: 100,
speed: 30,
height: '4',
types: ['nerd', 'electric'],
};
PokemonModel.update(query, mod, options, (err, data) => {
if (err) return console.log('ERROR: ', err);
console.log(data);
});
module.export = PokemonModel;
```
Resultado:
```shell
{ ok: 1,
nModified: 0,
n: 1,
upserted: [ { index: 0, _id: 56f746a2387837286197b269 } ] }
```
## Remova **todos** os Pokemons com `attack` **acima de 50**.
```js
PokemonModel.remove({attack: {$gt: 50}}, (err, data) => {
if (err) return console.log('ERROR: ', err);
console.log(data);
});
```
Resultado:
```shell
{ result: { ok: 1, n: 463 },
connection:
EventEmitter {
domain: null,
_events:
{ close: [Object],
error: [Object],
timeout: [Object],
parseError: [Object],
connect: [Function] },
_eventsCount: 5,
_maxListeners: undefined,
options:
{ socketOptions: {},
auto_reconnect: true,
host: 'localhost',
port: 27017,
cursorFactory: [Object],
reconnect: true,
emitError: true,
size: 5,
disconnectHandler: [Object],
bson: {},
messageHandler: [Function],
wireProtocolHandler: {} },
id: 0,
logger: { className: 'Connection' },
bson: {},
tag: undefined,
messageHandler: [Function],
maxBsonMessageSize: 67108864,
port: 27017,
host: 'localhost',
keepAlive: true,
keepAliveInitialDelay: 0,
noDelay: true,
connectionTimeout: 0,
socketTimeout: 0,
destroyed: false,
domainSocket: false,
singleBufferSerializtion: true,
serializationFunction: 'toBinUnified',
ca: null,
cert: null,
key: null,
passphrase: null,
ssl: false,
rejectUnauthorized: false,
checkServerIdentity: true,
responseOptions: { promoteLongs: true },
flushing: false,
queue: [],
connection:
Socket {
_connecting: false,
_hadError: false,
_handle: [Object],
_parent: null,
_host: 'localhost',
_readableState: [Object],
readable: true,
domain: null,
_events: [Object],
_eventsCount: 8,
_maxListeners: undefined,
_writableState: [Object],
writable: true,
allowHalfOpen: false,
destroyed: false,
bytesRead: 250,
_bytesDispatched: 231,
_sockname: null,
_pendingData: null,
_pendingEncoding: '',
server: null,
_server: null,
_idleNext: null,
_idlePrev: null,
_idleTimeout: -1,
read: [Function],
_consuming: true },
writeStream: null,
hashedName: '29bafad3b32b11dc7ce934204952515ea5984b3c',
buffer: null,
sizeOfMessage: 0,
bytesRead: 0,
stubBuffer: null } }
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |