diff --git a/curriculum/challenges/portuguese/05-apis-and-microservices/apis-and-microservices-projects/exercise-tracker.portuguese.md b/curriculum/challenges/portuguese/05-apis-and-microservices/apis-and-microservices-projects/exercise-tracker.portuguese.md new file mode 100644 index 0000000000..1c0bafca29 --- /dev/null +++ b/curriculum/challenges/portuguese/05-apis-and-microservices/apis-and-microservices-projects/exercise-tracker.portuguese.md @@ -0,0 +1,52 @@ +--- +id: 5a8b073d06fa14fcfde687aa +title: Exercise Tracker +localeTitle: Rastreador de Exercícios +challengeType: 4 +isRequired: true +--- + +## Description +
+Crie um aplicativo JavaScript de pilha completa que seja funcionalmente semelhante a este: https://fuschia-custard.glitch.me/ . +Trabalhar neste projeto envolverá você escrevendo seu código no Glitch em nosso projeto inicial. Depois de concluir este projeto, você pode copiar sua URL de falha pública (para a página inicial do seu aplicativo) nesta tela para testá-lo! Opcionalmente, você pode optar por escrever seu projeto em outra plataforma, mas deve estar publicamente visível para nossos testes. +iniciar este projeto em Glitch usando este link ou clonar este repositório no GitHub! Se você usa o Glitch, lembre-se de salvar o link do seu projeto em algum lugar seguro! +
+ +## Instructions +
+ +
+ +## Tests +
+ +```yml +tests: + - text: Eu posso criar um usuário postando dados do formulário username para / api / exercise / new-user e retornado será um objeto com username e _id . + testString: '' + - text: Eu posso obter uma matriz de todos os usuários obtendo api / exercise / users com as mesmas informações que ao criar um usuário. + testString: '' + - text: Posso adicionar um exercício a qualquer usuário postando dados do formulário userId (_id), descrição, duração e, opcionalmente, data para / api / exercise / add. Se nenhuma data for fornecida, usará a data atual. O aplicativo retornará o objeto do usuário com os campos de exercício adicionados. + testString: '' + - text: Eu posso recuperar um log de exercício completo de qualquer usuário obtendo / api / exercise / log com um parâmetro de userId (_id). O aplicativo retornará o objeto do usuário com o registro da matriz adicionado e a contagem (contagem total de exercícios). + testString: '' + - text: 'Eu posso recuperar parte do log de qualquer usuário passando também parâmetros opcionais de & para ou limite. (Formato de data aaaa-mm-dd, limite = int) ' + testString: '' + +``` + +
+ +## Challenge Seed +
+ +
+ +## Solution +
+ +```js +// solution required +``` +
diff --git a/curriculum/challenges/portuguese/05-apis-and-microservices/apis-and-microservices-projects/file-metadata-microservice.portuguese.md b/curriculum/challenges/portuguese/05-apis-and-microservices/apis-and-microservices-projects/file-metadata-microservice.portuguese.md new file mode 100644 index 0000000000..c2d6e82fc5 --- /dev/null +++ b/curriculum/challenges/portuguese/05-apis-and-microservices/apis-and-microservices-projects/file-metadata-microservice.portuguese.md @@ -0,0 +1,46 @@ +--- +id: bd7158d8c443edefaeb5bd0f +title: File Metadata Microservice +localeTitle: Metadados de Arquivo Microservice +challengeType: 4 +isRequired: true +--- + +## Description +
+Crie um aplicativo JavaScript de pilha completa que seja funcionalmente semelhante a este: https://purple-paladin.glitch.me/ . +Trabalhar neste projeto envolverá você escrevendo seu código no Glitch em nosso projeto inicial. Depois de concluir este projeto, você pode copiar sua URL de falha pública (para a página inicial do seu aplicativo) nesta tela para testá-lo! Opcionalmente, você pode optar por escrever seu projeto em outra plataforma, mas deve estar publicamente visível para nossos testes. +iniciar este projeto em Glitch usando este link ou clonar este repositório no GitHub! Se você usa o Glitch, lembre-se de salvar o link do seu projeto em algum lugar seguro! +
+ +## Instructions +
+ +
+ +## Tests +
+ +```yml +tests: + - text: Eu posso enviar um objeto FormData que inclua um upload de arquivo. + testString: '' + - text: 'Quando eu enviar algo, receberei o tamanho do arquivo em bytes dentro da resposta JSON.' + testString: '' + +``` + +
+ +## Challenge Seed +
+ +
+ +## Solution +
+ +```js +// solution required +``` +
diff --git a/curriculum/challenges/portuguese/05-apis-and-microservices/apis-and-microservices-projects/request-header-parser-microservice.portuguese.md b/curriculum/challenges/portuguese/05-apis-and-microservices/apis-and-microservices-projects/request-header-parser-microservice.portuguese.md new file mode 100644 index 0000000000..8c8b7bd53d --- /dev/null +++ b/curriculum/challenges/portuguese/05-apis-and-microservices/apis-and-microservices-projects/request-header-parser-microservice.portuguese.md @@ -0,0 +1,44 @@ +--- +id: bd7158d8c443edefaeb5bdff +title: Request Header Parser Microservice +localeTitle: Solicitar Microservice do Analisador de Cabeçalhos +challengeType: 4 +isRequired: true +--- + +## Description +
+Crie um aplicativo JavaScript de pilha completa que seja funcionalmente semelhante a este: https://dandelion-roar.glitch.me/ . +Trabalhar neste projeto envolverá você escrevendo seu código no Glitch em nosso projeto inicial. Depois de concluir este projeto, você pode copiar sua URL de falha pública (para a página inicial do seu aplicativo) nesta tela para testá-lo! Opcionalmente, você pode optar por escrever seu projeto em outra plataforma, mas deve estar publicamente visível para nossos testes. +iniciar este projeto em Glitch usando este link ou clonar este repositório no GitHub! Se você usa o Glitch, lembre-se de salvar o link do seu projeto em algum lugar seguro! +
+ +## Instructions +
+ +
+ +## Tests +
+ +```yml +tests: + - text: 'Eu posso obter o endereço IP, idioma e sistema operacional para o meu navegador.' + testString: '' + +``` + +
+ +## Challenge Seed +
+ +
+ +## Solution +
+ +```js +// solution required +``` +
diff --git a/curriculum/challenges/portuguese/05-apis-and-microservices/apis-and-microservices-projects/timestamp-microservice.portuguese.md b/curriculum/challenges/portuguese/05-apis-and-microservices/apis-and-microservices-projects/timestamp-microservice.portuguese.md new file mode 100644 index 0000000000..a0c9efbe36 --- /dev/null +++ b/curriculum/challenges/portuguese/05-apis-and-microservices/apis-and-microservices-projects/timestamp-microservice.portuguese.md @@ -0,0 +1,54 @@ +--- +id: bd7158d8c443edefaeb5bdef +title: Timestamp Microservice +localeTitle: Microservice de registro de data e hora +challengeType: 4 +isRequired: true +--- + +## Description +
+Crie um aplicativo JavaScript de pilha completa que seja funcionalmente semelhante a este: https://curse-arrow.glitch.me/ . +Trabalhar neste projeto envolverá você escrevendo seu código no Glitch em nosso projeto inicial. Depois de concluir este projeto, você pode copiar sua URL de falha pública (para a página inicial do seu aplicativo) nesta tela para testá-lo! Opcionalmente, você pode optar por escrever seu projeto em outra plataforma, mas deve estar publicamente visível para nossos testes. +iniciar este projeto em Glitch usando este link ou clonar este repositório no GitHub! Se você usa o Glitch, lembre-se de salvar o link do seu projeto em algum lugar seguro! +
+ +## Instructions +
+ +
+ +## Tests +
+ +```yml +tests: + - text: 'Ele deve manipular uma data válida e retornar o registro de data e hora correto do unix' + testString: 'getUserInput => $.get(getUserInput(''url'') + ''/api/timestamp/2016-12-25'').then(data => { assert.equal(data.unix, 1482624000000, ''Should be a valid unix timestamp''); }, xhr => { throw new Error(xhr.responseText); })' + - text: 'Ele deve manipular uma data válida e retornar a string UTC correta' + testString: 'getUserInput => $.get(getUserInput(''url'')+ ''/api/timestamp/2016-12-25'').then(data => { assert.equal(data.utc, ''Sun, 25 Dec 2016 00:00:00 GMT'', ''Should be a valid UTC date string''); }, xhr => { throw new Error(xhr.responseText); })' + - text: 'Ele deve manipular uma data unix válida e retornar o registro de data e hora correto do unix' + testString: 'getUserInput => $.get(getUserInput(''url'') + ''/api/timestamp/1482624000000'').then(data => { assert.equal(data.unix, 1482624000000) ; }, xhr => { throw new Error(xhr.responseText); })' + - text: Deve devolver a mensagem de erro esperada para uma data inválida + testString: 'getUserInput => $.get(getUserInput(''url'') + ''/api/timestamp/this-is-not-a-date'').then(data => { assert.equal(data.error.toLowerCase(), ''invalid date'');}, xhr => { throw new Error(xhr.responseText); })' + - text: 'Ele deve manipular um parâmetro de data vazio e retornar a hora atual no formato unix' + testString: 'getUserInput => $.get(getUserInput(''url'') + ''/api/timestamp'').then(data => { var now = Date.now(); assert.approximately(data.unix, now, 20000) ;}, xhr => { throw new Error(xhr.responseText); })' + - text: 'Ele deve manipular um parâmetro de data vazio e retornar a hora atual no formato UTC' + testString: 'getUserInput => $.get(getUserInput(''url'') + ''/api/timestamp'').then(data => { var now = Date.now(); var serverTime = (new Date(data.utc)).getTime(); assert.approximately(serverTime, now, 20000) ;}, xhr => { throw new Error(xhr.responseText); })' + +``` + +
+ +## Challenge Seed +
+ +
+ +## Solution +
+ +```js +// solution required +``` +
diff --git a/curriculum/challenges/portuguese/05-apis-and-microservices/apis-and-microservices-projects/url-shortener-microservice.portuguese.md b/curriculum/challenges/portuguese/05-apis-and-microservices/apis-and-microservices-projects/url-shortener-microservice.portuguese.md new file mode 100644 index 0000000000..e3492df1e4 --- /dev/null +++ b/curriculum/challenges/portuguese/05-apis-and-microservices/apis-and-microservices-projects/url-shortener-microservice.portuguese.md @@ -0,0 +1,48 @@ +--- +id: bd7158d8c443edefaeb5bd0e +title: URL Shortener Microservice +localeTitle: Microservice do Shortener de URL +challengeType: 4 +isRequired: true +--- + +## Description +
+Crie um aplicativo JavaScript de pilha completa que seja funcionalmente semelhante a este: https://thread-paper.glitch.me/ . +Trabalhar neste projeto envolverá você escrevendo seu código no Glitch em nosso projeto inicial. Depois de concluir este projeto, você pode copiar sua URL de falha pública (para a página inicial do seu aplicativo) nesta tela para testá-lo! Opcionalmente, você pode optar por escrever seu projeto em outra plataforma, mas deve estar publicamente visível para nossos testes. +iniciar este projeto em Glitch usando este link ou clonar este repositório no GitHub! Se você usa o Glitch, lembre-se de salvar o link do seu projeto em algum lugar seguro! +
+ +## Instructions +
+ +
+ +## Tests +
+ +```yml +tests: + - text: Posso passar um URL como parâmetro e receberei um URL abreviado na resposta JSON. + testString: '' + - text: 'Se eu passar um URL inválido que não segue o formato http://www.example.com válido, a resposta JSON conterá um erro.' + testString: '' + - text: "Quando visito esse URL encurtado, ele me redireciona para o meu link original." + testString: '' + +``` + +
+ +## Challenge Seed +
+ +
+ +## Solution +
+ +```js +// solution required +``` +
diff --git a/curriculum/challenges/portuguese/05-apis-and-microservices/basic-node-and-express/chain-middleware-to-create-a-time-server.portuguese.md b/curriculum/challenges/portuguese/05-apis-and-microservices/basic-node-and-express/chain-middleware-to-create-a-time-server.portuguese.md new file mode 100644 index 0000000000..7fdc040c85 --- /dev/null +++ b/curriculum/challenges/portuguese/05-apis-and-microservices/basic-node-and-express/chain-middleware-to-create-a-time-server.portuguese.md @@ -0,0 +1,48 @@ +--- +id: 587d7fb1367417b2b2512bf4 +title: Chain Middleware to Create a Time Server +localeTitle: Chain Middleware para criar um servidor de horário +challengeType: 2 +--- + +## Description +
+Middleware pode ser montado em uma rota específica usando app.METHOD(path, middlewareFunction) . O middleware também pode ser encadeado dentro da definição da rota. +Veja o seguinte exemplo: +
app.get('/user', function(req, res, next) {
req.user = getTheUserSync(); // Hypothetical synchronous operation
next();
}, function(req, res) {
res.send(req.user);
})
+Essa abordagem é útil para dividir as operações do servidor em unidades menores. Isso leva a uma estrutura de aplicativo melhor e à possibilidade de reutilizar códigos em locais diferentes. Essa abordagem também pode ser usada para executar alguma validação nos dados. Em cada ponto da pilha de middlewares, você pode bloquear a execução da corrente atual e passar o controle para funções especificamente projetadas para lidar com erros. Ou você pode passar o controle para a próxima rota correspondente, para lidar com casos especiais. Vamos ver como na seção Express avançada. +Na rota app.get('/now', ...) uma função de middleware e o manipulador final. Na função middleware você deve adicionar a hora atual ao objeto request na chave req.time . Você pode usar o new Date().toString() . No manipulador, responda com um objeto JSON, usando a estrutura {time: req.time} . +Dica: O teste não passará se você não encadear o middleware. Se você montar a função em outro lugar, o teste falhará, mesmo se o resultado da saída estiver correto. +
+ +## Instructions +
+ +
+ +## Tests +
+ +```yml +tests: + - text: O ponto de extremidade / now deve ter o middleware montado + testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/chain-middleware-time'').then(data => { assert.equal(data.stackLength, 2, ''"/now" route has no mounted middleware''); }, xhr => { throw new Error(xhr.responseText); })' + - text: O ponto final / now deve retornar um tempo que é de +/- 20 segundos a partir de agora + testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/chain-middleware-time'').then(data => { var now = new Date(); assert.isAtMost(Math.abs(new Date(data.time) - now), 20000, ''the returned time is not between +- 20 secs from now''); }, xhr => { throw new Error(xhr.responseText); })' + +``` + +
+ +## Challenge Seed +
+ +
+ +## Solution +
+ +```js +// solution required +``` +
diff --git a/curriculum/challenges/portuguese/05-apis-and-microservices/basic-node-and-express/get-data-from-post-requests.portuguese.md b/curriculum/challenges/portuguese/05-apis-and-microservices/basic-node-and-express/get-data-from-post-requests.portuguese.md new file mode 100644 index 0000000000..bdf0f1c75d --- /dev/null +++ b/curriculum/challenges/portuguese/05-apis-and-microservices/basic-node-and-express/get-data-from-post-requests.portuguese.md @@ -0,0 +1,51 @@ +--- +id: 587d7fb2367417b2b2512bf8 +title: Get Data from POST Requests +localeTitle: Obter dados de solicitações de POST +challengeType: 2 +--- + +## Description +
+Monte um manipulador POST no caminho /name . É o mesmo caminho de antes. Nós preparamos um formulário no frontpage html. Ele enviará os mesmos dados do exercício 10 (string de consulta). Se o analisador de corpo estiver configurado corretamente, você deverá encontrar os parâmetros no objeto req.body . Dê uma olhada no exemplo usual de biblioteca: +
route: POST '/library'
urlencoded_body: userId=546&bookId=6754
req.body: {userId: '546', bookId: '6754'}
+Responda com o mesmo objeto JSON de antes: {name: 'firstname lastname'} . Teste se seu endpoint funciona usando o formulário html fornecido na página principal do aplicativo. +Dica: Existem vários outros métodos de HTTP além de GET e POST. E por convenção existe uma correspondência entre o verbo http e a operação que você vai executar no servidor. O mapeamento convencional é: +POST (às vezes PUT) - Cria um novo recurso usando as informações enviadas com o pedido, +GET - Lê um recurso existente sem modificá-lo, +PUT ou PATCH (às vezes POST) - Atualiza um recurso usando os dados enviado, +DELETE => Excluir um recurso. +Existem também alguns outros métodos que são usados para negociar uma conexão com o servidor. Exceto pelo GET, todos os outros métodos listados acima podem ter uma carga útil (ou seja, os dados no corpo da solicitação). O middleware do analisador de corpo também funciona com esses métodos. +
+ +## Instructions +
+ +
+ +## Tests +
+ +```yml +tests: + - text: 'Teste 1: o endpoint da sua API deve responder com o nome correto' + testString: 'getUserInput => $.post(getUserInput(''url'') + ''/name'', {first: ''Mick'', last: ''Jagger''}).then(data => { assert.equal(data.name, ''Mick Jagger'', ''Test 1: "POST /name" route does not behave as expected'') }, xhr => { throw new Error(xhr.responseText); })' + - text: 'Teste 2: seu endpoint da API deve responder com o nome correto' + testString: 'getUserInput => $.post(getUserInput(''url'') + ''/name'', {first: ''Keith'', last: ''Richards''}).then(data => { assert.equal(data.name, ''Keith Richards'', ''Test 2: "POST /name" route does not behave as expected'') }, xhr => { throw new Error(xhr.responseText); })' + +``` + +
+ +## Challenge Seed +
+ +
+ +## Solution +
+ +```js +// solution required +``` +
diff --git a/curriculum/challenges/portuguese/05-apis-and-microservices/basic-node-and-express/get-query-parameter-input-from-the-client.portuguese.md b/curriculum/challenges/portuguese/05-apis-and-microservices/basic-node-and-express/get-query-parameter-input-from-the-client.portuguese.md new file mode 100644 index 0000000000..5c70ae6960 --- /dev/null +++ b/curriculum/challenges/portuguese/05-apis-and-microservices/basic-node-and-express/get-query-parameter-input-from-the-client.portuguese.md @@ -0,0 +1,46 @@ +--- +id: 587d7fb2367417b2b2512bf6 +title: Get Query Parameter Input from the Client +localeTitle: Obter entrada de parâmetro de consulta do cliente +challengeType: 2 +--- + +## Description +
+Outra maneira comum de obter entrada do cliente é codificando os dados após o caminho da rota, usando uma string de consulta. A cadeia de consulta é delimitada por um ponto de interrogação (?) E inclui pares campo = valor. Cada casal é separado por um e comercial (&). O Express pode analisar os dados da cadeia de consulta e preencher o objeto req.query . Alguns caracteres não podem estar em URLs, eles precisam ser codificados em um formato diferente antes de você poder enviá-los. Se você usar a API do JavaScript, poderá usar métodos específicos para codificar / decodificar esses caracteres. +
route_path: '/library'
actual_request_URL: '/library?userId=546&bookId=6754'
req.query: {userId: '546', bookId: '6754'}
+Construa um endpoint da API, montado em GET /name . Responda com um documento JSON, tomando a estrutura { name: 'firstname lastname'} . Os parâmetros de nome e sobrenome devem ser codificados em uma string de consulta, por exemplo, ?first=firstname&last=lastname . +DICA: No exercício a seguir, vamos receber dados de uma solicitação POST, no mesmo caminho de rota /name . Se você quiser, pode usar o método app.route(path).get(handler).post(handler) . Essa sintaxe permite encadear diferentes manipuladores de verbo na mesma rota de caminho. Você pode economizar um pouco de digitação e ter um código mais limpo. +
+ +## Instructions +
+ +
+ +## Tests +
+ +```yml +tests: + - text: 'Teste 1: o endpoint da sua API deve responder com o nome correto' + testString: 'getUserInput => $.get(getUserInput(''url'') + ''/name?first=Mick&last=Jagger'').then(data => { assert.equal(data.name, ''Mick Jagger'', ''Test 1: "GET /name" route does not behave as expected'') }, xhr => { throw new Error(xhr.responseText); })' + - text: 'Teste 2: seu ponto de extremidade APi deve responder com o nome correto' + testString: 'getUserInput => $.get(getUserInput(''url'') + ''/name?last=Richards&first=Keith'').then(data => { assert.equal(data.name, ''Keith Richards'', ''Test 2: "GET /name" route does not behave as expected'') }, xhr => { throw new Error(xhr.responseText); })' + +``` + +
+ +## Challenge Seed +
+ +
+ +## Solution +
+ +```js +// solution required +``` +
diff --git a/curriculum/challenges/portuguese/05-apis-and-microservices/basic-node-and-express/get-route-parameter-input-from-the-client.portuguese.md b/curriculum/challenges/portuguese/05-apis-and-microservices/basic-node-and-express/get-route-parameter-input-from-the-client.portuguese.md new file mode 100644 index 0000000000..c673be146f --- /dev/null +++ b/curriculum/challenges/portuguese/05-apis-and-microservices/basic-node-and-express/get-route-parameter-input-from-the-client.portuguese.md @@ -0,0 +1,45 @@ +--- +id: 587d7fb2367417b2b2512bf5 +title: Get Route Parameter Input from the Client +localeTitle: Obter entrada de parâmetro de rota do cliente +challengeType: 2 +--- + +## Description +
+Ao criar uma API, precisamos permitir que os usuários nos comuniquem o que desejam obter de nosso serviço. Por exemplo, se o cliente estiver solicitando informações sobre um usuário armazenado no banco de dados, ele precisará de uma maneira de nos informar em qual usuário está interessado. Uma maneira possível de obter esse resultado é usando parâmetros de rota. Os parâmetros de rota são denominados segmentos da URL, delimitados por barras (/). Cada segmento captura o valor da parte do URL que corresponde à sua posição. Os valores capturados podem ser encontrados no objeto req.params . +
route_path: '/user/:userId/book/:bookId'
actual_request_URL: '/user/546/book/6754'
req.params: {userId: '546', bookId: '6754'}
+Construa um servidor de eco, montado na rota GET /:word/echo . Responda com um objeto JSON, tomando a estrutura {echo: word} . Você pode encontrar a palavra a ser repetida em req.params.word . Você pode testar sua rota a partir da barra de endereços do seu navegador, visitando algumas rotas correspondentes, por exemplo, your-app-rootpath / freecodecamp / echo +
+ +## Instructions +
+ +
+ +## Tests +
+ +```yml +tests: + - text: 'Teste 1: seu servidor de eco deve repetir palavras corretamente' + testString: 'getUserInput => $.get(getUserInput(''url'') + ''/eChOtEsT/echo'').then(data => { assert.equal(data.echo, ''eChOtEsT'', ''Test 1: the echo server is not working as expected'') }, xhr => { throw new Error(xhr.responseText); })' + - text: 'Teste 2: seu servidor de eco deve repetir palavras corretamente' + testString: 'getUserInput => $.get(getUserInput(''url'') + ''/ech0-t3st/echo'').then(data => { assert.equal(data.echo, ''ech0-t3st'', ''Test 2: the echo server is not working as expected'') }, xhr => { throw new Error(xhr.responseText); })' + +``` + +
+ +## Challenge Seed +
+ +
+ +## Solution +
+ +```js +// solution required +``` +
diff --git a/curriculum/challenges/portuguese/05-apis-and-microservices/basic-node-and-express/implement-a-root-level-request-logger-middleware.portuguese.md b/curriculum/challenges/portuguese/05-apis-and-microservices/basic-node-and-express/implement-a-root-level-request-logger-middleware.portuguese.md new file mode 100644 index 0000000000..33ef39dfae --- /dev/null +++ b/curriculum/challenges/portuguese/05-apis-and-microservices/basic-node-and-express/implement-a-root-level-request-logger-middleware.portuguese.md @@ -0,0 +1,47 @@ +--- +id: 587d7fb1367417b2b2512bf3 +title: Implement a Root-Level Request Logger Middleware +localeTitle: Implementar um middleware de logger de solicitação de nível raiz +challengeType: 2 +--- + +## Description +
+Antes de introduzirmos a função de middleware express.static() . Agora é hora de ver qual middleware é, com mais detalhes. As funções de middleware são funções que levam 3 argumentos: o objeto de solicitação, o objeto de resposta e a próxima função no ciclo de solicitação-resposta do aplicativo. Essas funções executam algum código que pode ter efeitos colaterais no aplicativo e geralmente adicionam informações aos objetos de solicitação ou resposta. Eles também podem terminar o ciclo enviando a resposta, quando alguma condição é atendida. Se eles não enviarem a resposta, quando eles terminarem, iniciarão a execução da próxima função na pilha. Isso é acionado chamando o terceiro argumento em next() . Mais informações na documentação expressa . +Veja o seguinte exemplo: +
function(req, res, next) {
console.log("I'm a middleware...");
next();
}
+Vamos supor que montamos essa função em uma rota. Quando uma solicitação corresponde à rota, ela exibe a string "Sou um middleware ...". Em seguida, ele executa a próxima função na pilha. +Neste exercício, vamos construir um middleware de nível raiz. Como vimos no desafio 4, para montar uma função de middleware no nível da raiz, podemos usar o método app.use(<mware-function>) . Nesse caso, a função será executada para todas as solicitações, mas você também pode definir condições mais específicas. Por exemplo, se você quiser que uma função seja executada apenas para solicitações POST, você pode usar app.post(<mware-function>) . Existem métodos análogos para todos os verbos http (GET, DELETE, PUT,…). +Construa um logger simples. Para cada requisição, deve logar no console uma string tomando o seguinte formato: method path - ip . Um exemplo seria: GET /json - ::ffff:127.0.0.1 . Observe que há um espaço entre o method e o path e que o traço que separa o path e o ip é cercado por um espaço em ambos os lados. Você pode obter o método de solicitação (verbo http), o caminho de rota relativo e o ip do chamador do objeto de solicitação, usando req.method , req.path e req.ip Lembre-se de chamar next() quando terminar, ou seu servidor ficará preso para sempre. Certifique-se de ter aberto o 'Logs' e veja o que acontece quando chega algum pedido… +Dica: o Express avalia funções na ordem em que aparecem no código. Isso também é verdade para o middleware. Se você quer que ele funcione para todas as rotas, ele deve ser montado antes delas. +
+ +## Instructions +
+ +
+ +## Tests +
+ +```yml +tests: + - text: O middleware do registrador de nível raiz deve estar ativo + testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/root-middleware-logger'').then(data => { assert.isTrue(data.passed, ''root-level logger is not working as expected''); }, xhr => { throw new Error(xhr.responseText); })' + +``` + +
+ +## Challenge Seed +
+ +
+ +## Solution +
+ +```js +// solution required +``` +
diff --git a/curriculum/challenges/portuguese/05-apis-and-microservices/basic-node-and-express/meet-the-node-console.portuguese.md b/curriculum/challenges/portuguese/05-apis-and-microservices/basic-node-and-express/meet-the-node-console.portuguese.md new file mode 100644 index 0000000000..9a00f328b9 --- /dev/null +++ b/curriculum/challenges/portuguese/05-apis-and-microservices/basic-node-and-express/meet-the-node-console.portuguese.md @@ -0,0 +1,42 @@ +--- +id: 587d7fb0367417b2b2512bed +title: Meet the Node console +localeTitle: Conheça o console do nó +challengeType: 2 +--- + +## Description +
+Durante o processo de desenvolvimento, é importante poder verificar o que está acontecendo em seu código. O nó é apenas um ambiente JavaScript. Como o JavaScript do lado do cliente, você pode usar o console para exibir informações de depuração úteis. Na sua máquina local, você veria a saída do console em um terminal. Na Glitch você pode abrir os logs na parte inferior da tela. Você pode alternar o painel de registro com o botão "Registros" (no canto superior esquerdo, sob o nome do aplicativo). +Para começar, basta imprimir o clássico "Hello World" no console. Recomendamos manter o painel de registro aberto enquanto trabalha nesses desafios. Lendo os logs você pode estar ciente da natureza dos erros que podem ocorrer. +
+ +## Instructions +
+Modifique o arquivo myApp.js para registrar "Hello World" no console. +
+ +## Tests +
+ +```yml +tests: + - text: "Hello World" deve estar no console + testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/hello-console'').then(data => { assert.isTrue(data.passed, ''"Hello World" is not in the server console''); }, xhr => { throw new Error(xhr.responseText); })' + +``` + +
+ +## Challenge Seed +
+ +
+ +## Solution +
+ +```js +// solution required +``` +
diff --git a/curriculum/challenges/portuguese/05-apis-and-microservices/basic-node-and-express/serve-an-html-file.portuguese.md b/curriculum/challenges/portuguese/05-apis-and-microservices/basic-node-and-express/serve-an-html-file.portuguese.md new file mode 100644 index 0000000000..e2e3d5db35 --- /dev/null +++ b/curriculum/challenges/portuguese/05-apis-and-microservices/basic-node-and-express/serve-an-html-file.portuguese.md @@ -0,0 +1,45 @@ +--- +id: 587d7fb0367417b2b2512bef +title: Serve an HTML File +localeTitle: Servir um arquivo HTML +challengeType: 2 +--- + +## Description +
+Podemos responder com um arquivo usando o método res.sendFile(path) . +Você pode colocá-lo dentro do manipulador de rota app.get('/', ...) . Nos bastidores, este método irá definir os cabeçalhos apropriados para instruir o seu navegador sobre como lidar com o arquivo que você deseja enviar, de acordo com o seu tipo. Então ele irá ler e enviar o arquivo. Esse método precisa de um caminho de arquivo absoluto. Recomendamos que você use a variável global do nó __dirname para calcular o caminho. +exemplo absolutePath = __dirname + relativePath/file.ext . +O arquivo a ser enviado é /views/index.html . Tente "Mostrar ao vivo" seu aplicativo, você deve ver um grande título HTML (e um formulário que usaremos mais tarde ...), sem estilo aplicado. +Nota: Você pode editar a solução do desafio anterior ou criar uma nova. Se você criar uma nova solução, lembre-se de que o Express avalia as rotas de cima para baixo. Ele executa o manipulador para o primeiro jogo. Você precisa comentar a solução anterior ou o servidor continuará respondendo com uma string. +
+ +## Instructions +
+ +
+ +## Tests +
+ +```yml +tests: + - text: Seu aplicativo deve exibir o arquivo views / index.html + testString: 'getUserInput => $.get(getUserInput(''url'')).then(data => { assert.match(data, /

.*<\/h1>/, ''Your app does not serve the expected HTML''); }, xhr => { throw new Error(xhr.responseText); })' + +``` + +

+ +## Challenge Seed +
+ +
+ +## Solution +
+ +```js +// solution required +``` +
diff --git a/curriculum/challenges/portuguese/05-apis-and-microservices/basic-node-and-express/serve-json-on-a-specific-route.portuguese.md b/curriculum/challenges/portuguese/05-apis-and-microservices/basic-node-and-express/serve-json-on-a-specific-route.portuguese.md new file mode 100644 index 0000000000..2dd3334f16 --- /dev/null +++ b/curriculum/challenges/portuguese/05-apis-and-microservices/basic-node-and-express/serve-json-on-a-specific-route.portuguese.md @@ -0,0 +1,43 @@ +--- +id: 587d7fb1367417b2b2512bf1 +title: Serve JSON on a Specific Route +localeTitle: Servir JSON em uma rota específica +challengeType: 2 +--- + +## Description +
+Enquanto um servidor HTML exibe (você adivinhou!) HTML, uma API exibe dados. Uma API REST (REpresentational State Transfer) permite a troca de dados de maneira simples, sem a necessidade de os clientes conhecerem detalhes sobre o servidor. O cliente só precisa saber onde o recurso está (a URL) e a ação que deseja executar nele (o verbo). O verbo GET é usado quando você está buscando algumas informações, sem modificar nada. Atualmente, o formato de dados preferencial para mover informações pela Web é o JSON. Simplificando, o JSON é uma maneira conveniente de representar um objeto JavaScript como uma string, para que ele possa ser facilmente transmitido. +Vamos criar uma API simples criando uma rota que responda com JSON no caminho /json . Você pode fazer isso normalmente, com o método app.get() . Dentro do manipulador de rota, use o método res.json() , passando um objeto como argumento. Este método fecha o loop de solicitação-resposta, retornando os dados. Nos bastidores, ele converte um objeto JavaScript válido em uma string e, em seguida, define os cabeçalhos apropriados para informar ao seu navegador que você está exibindo JSON e envia os dados de volta. Um objeto válido tem a estrutura usual {key: data} . Os dados podem ser um número, uma string, um objeto aninhado ou uma matriz. Os dados também podem ser uma variável ou o resultado de uma chamada de função; nesse caso, ela será avaliada antes de ser convertida em uma string. +Sirva o objeto {"message": "Hello json"} como uma resposta no formato JSON, para as requisições GET para o route /json . Em seguida, aponte seu navegador para seu app-url / json, você deverá ver a mensagem na tela. +
+ +## Instructions +
+ +
+ +## Tests +
+ +```yml +tests: + - text: 'O endpoint /json deve servir o objeto json {"message": "Hello json"} ' + testString: 'getUserInput => $.get(getUserInput(''url'') + ''/json'').then(data => { assert.equal(data.message, ''Hello json'', ''The \''/json\'' endpoint does not serve the right data''); }, xhr => { throw new Error(xhr.responseText); })' + +``` + +
+ +## Challenge Seed +
+ +
+ +## Solution +
+ +```js +// solution required +``` +
diff --git a/curriculum/challenges/portuguese/05-apis-and-microservices/basic-node-and-express/serve-static-assets.portuguese.md b/curriculum/challenges/portuguese/05-apis-and-microservices/basic-node-and-express/serve-static-assets.portuguese.md new file mode 100644 index 0000000000..359efe4150 --- /dev/null +++ b/curriculum/challenges/portuguese/05-apis-and-microservices/basic-node-and-express/serve-static-assets.portuguese.md @@ -0,0 +1,43 @@ +--- +id: 587d7fb0367417b2b2512bf0 +title: Serve Static Assets +localeTitle: Ative os recursos estáticos +challengeType: 2 +--- + +## Description +
+Um servidor HTML geralmente possui um ou mais diretórios que são acessíveis pelo usuário. Você pode colocar aí os recursos estáticos necessários para sua aplicação (folhas de estilo, scripts, imagens). No Express, você pode colocar em prática essa funcionalidade usando o middleware express.static(path) , em que o parâmetro é o caminho absoluto da pasta que contém os ativos. Se você não sabe o que é um middleware, não se preocupe. Vamos discutir sobre isso mais tarde em detalhes. Basicamente middlewares são funções que interceptam manipuladores de rota, adicionando algum tipo de informação. Um middleware precisa ser montado usando o método app.use(path, middlewareFunction) . O primeiro argumento de caminho é opcional. Se você não passar, o middleware será executado para todas as requisições. +Monte o middleware express.static() para todas as solicitações com app.use() . O caminho absoluto para a pasta de recursos é __dirname + /public . +Agora, seu aplicativo deve poder exibir uma folha de estilo CSS. De fora a pasta pública aparecerá montada no diretório raiz. Sua primeira página deve parecer um pouco melhor agora! +
+ +## Instructions +
+ +
+ +## Tests +
+ +```yml +tests: + - text: Seu aplicativo deve exibir arquivos de recursos do diretório /public + testString: 'getUserInput => $.get(getUserInput(''url'') + ''/style.css'').then(data => { assert.match(data, /body\s*\{[^\}]*\}/, ''Your app does not serve static assets''); }, xhr => { throw new Error(xhr.responseText); })' + +``` + +
+ +## Challenge Seed +
+ +
+ +## Solution +
+ +```js +// solution required +``` +
diff --git a/curriculum/challenges/portuguese/05-apis-and-microservices/basic-node-and-express/start-a-working-express-server.portuguese.md b/curriculum/challenges/portuguese/05-apis-and-microservices/basic-node-and-express/start-a-working-express-server.portuguese.md new file mode 100644 index 0000000000..c85a0c3b89 --- /dev/null +++ b/curriculum/challenges/portuguese/05-apis-and-microservices/basic-node-and-express/start-a-working-express-server.portuguese.md @@ -0,0 +1,46 @@ +--- +id: 587d7fb0367417b2b2512bee +title: Start a Working Express Server +localeTitle: Inicie um servidor do Working Express +challengeType: 2 +--- + +## Description +
+Nas duas primeiras linhas do arquivo myApp.js você pode ver como é fácil criar um objeto de aplicativo Express. Esse objeto tem vários métodos e aprenderemos muitos deles nesses desafios. Um método fundamental é app.listen(port) . Ele diz ao seu servidor para escutar em uma determinada porta, colocando-o em estado de execução. Você pode vê-lo na parte inferior do arquivo. Ele está dentro dos comentários porque, por motivos de teste, precisamos que o aplicativo esteja em execução em segundo plano. Todo o código que você deseja adicionar vai entre essas duas partes fundamentais. Glitch armazena o número da porta na variável de ambiente process.env.PORT . Seu valor é 3000 . +Vamos servir nossa primeira string! No Express, as rotas levam a seguinte estrutura: app.METHOD(PATH, HANDLER) . MÉTODO é um método http em minúsculas. PATH é um caminho relativo no servidor (pode ser uma string ou até uma expressão regular). HANDLER é uma função que o Express chama quando a rota é correspondida. +Manipuladores assumem a function(req, res) {...} form function(req, res) {...} , em que req é o objeto request e res é o objeto response. Por exemplo, o manipulador +
function(req, res) {
res.send('Response String');
}
+servirá a string 'Response String'. +Use o método app.get() para exibir a string Hello Express, para solicitações GET correspondentes ao caminho / root. Certifique-se de que seu código funciona observando os registros e, em seguida, veja os resultados no seu navegador, clicando no botão "Mostrar ao vivo" na interface do usuário do Glitch. +
+ +## Instructions +
+ +
+ +## Tests +
+ +```yml +tests: + - text: Seu aplicativo deve exibir a string "Hello Express" + testString: 'getUserInput => $.get(getUserInput(''url'')).then(data => { assert.equal(data, ''Hello Express'', ''Your app does not serve the text "Hello Express"''); }, xhr => { throw new Error(xhr.responseText); })' + +``` + +
+ +## Challenge Seed +
+ +
+ +## Solution +
+ +```js +// solution required +``` +
diff --git a/curriculum/challenges/portuguese/05-apis-and-microservices/basic-node-and-express/use-body-parser-to-parse-post-requests.portuguese.md b/curriculum/challenges/portuguese/05-apis-and-microservices/basic-node-and-express/use-body-parser-to-parse-post-requests.portuguese.md new file mode 100644 index 0000000000..6c38939ba1 --- /dev/null +++ b/curriculum/challenges/portuguese/05-apis-and-microservices/basic-node-and-express/use-body-parser-to-parse-post-requests.portuguese.md @@ -0,0 +1,48 @@ +--- +id: 587d7fb2367417b2b2512bf7 +title: Use body-parser to Parse POST Requests +localeTitle: Use o analisador de corpo para analisar solicitações de POST +challengeType: 2 +--- + +## Description +
+Além de GET, existe outro verbo http comum, é o POST. POST é o método padrão usado para enviar dados do cliente com formulários HTML. Na convenção REST, o POST é usado para enviar dados para criar novos itens no banco de dados (um novo usuário ou uma nova postagem no blog). Não temos um banco de dados neste projeto, mas vamos aprender como lidar com solicitações POST de qualquer maneira. +Nesse tipo de solicitações, os dados não aparecem no URL, eles estão ocultos no corpo da solicitação. Esta é uma parte da solicitação HTML, também chamada de payload. Como o HTML é baseado em texto, mesmo que você não veja os dados, isso não significa que eles sejam secretos. O conteúdo bruto de uma solicitação HTTP POST é mostrado abaixo: +
POST /path/subpath HTTP/1.0
From: john@example.com
User-Agent: someBrowser/1.0
Content-Type: application/x-www-form-urlencoded
Content-Length: 20
name=John+Doe&age=25
+Como você pode ver, o corpo é codificado como a string de consulta. Este é o formato padrão usado pelos formulários HTML. Com o Ajax, também podemos usar JSON para manipular dados com uma estrutura mais complexa. Há também outro tipo de codificação: multipart / form-data. Este é usado para fazer upload de arquivos binários. +Neste exercício, usaremos um corpo com codificação de URL. +Para analisar os dados provenientes de solicitações POST, você precisa instalar um pacote: o analisador de corpo. Este pacote permite que você use uma série de middleware, que pode decodificar dados em diferentes formatos. Veja os documentos aqui . +Instale o módulo body-parser no seu package.json. Em seguida, solicite-o no topo do arquivo. Armazene-o em uma variável chamada bodyParser. +O middleware para manipular dados codificados em URL é retornado por bodyParser.urlencoded({extended: false}) . extended=false é uma opção de configuração que diz ao analisador para usar a codificação clássica. Ao usá-lo, os valores podem ser apenas strings ou matrizes. A versão estendida permite mais flexibilidade de dados, mas é superada pelo JSON. Passe para app.use() a função retornada pela chamada do método anterior. Como de costume, o middleware deve ser montado antes de todas as rotas que precisam dele. +
+ +## Instructions +
+ +
+ +## Tests +
+ +```yml +tests: + - text: O middleware 'body-parser' deve ser montado + testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/add-body-parser'').then(data => { assert.isAbove(data.mountedAt, 0, ''"body-parser" is not mounted correctly'') }, xhr => { throw new Error(xhr.responseText); })' + +``` + +
+ +## Challenge Seed +
+ +
+ +## Solution +
+ +```js +// solution required +``` +
diff --git a/curriculum/challenges/portuguese/05-apis-and-microservices/basic-node-and-express/use-the-.env-file.portuguese.md b/curriculum/challenges/portuguese/05-apis-and-microservices/basic-node-and-express/use-the-.env-file.portuguese.md new file mode 100644 index 0000000000..090e0df61f --- /dev/null +++ b/curriculum/challenges/portuguese/05-apis-and-microservices/basic-node-and-express/use-the-.env-file.portuguese.md @@ -0,0 +1,43 @@ +--- +id: 587d7fb1367417b2b2512bf2 +title: Use the .env File +localeTitle: Use o arquivo .env +challengeType: 2 +--- + +## Description +
+O arquivo .env é um arquivo oculto usado para transmitir variáveis de ambiente ao seu aplicativo. Este arquivo é secreto, ninguém além de você pode acessá-lo e pode ser usado para armazenar dados que você deseja manter privados ou ocultos. Por exemplo, você pode armazenar chaves de API de serviços externos ou do URI do seu banco de dados. Você também pode usá-lo para armazenar opções de configuração. Ao definir opções de configuração, você pode alterar o comportamento do seu aplicativo, sem a necessidade de reescrever algum código. +As variáveis de ambiente podem ser acessadas no aplicativo como process.env.VAR_NAME . O objeto process.env é um objeto Node global e as variáveis são passadas como strings. Por convenção, os nomes das variáveis são todos em maiúsculas, com palavras separadas por um sublinhado. O .env é um arquivo de shell, portanto, você não precisa .env nomes ou valores entre aspas. Também é importante observar que não pode haver espaço ao redor do sinal de igual quando você está atribuindo valores às suas variáveis, por exemplo, VAR_NAME=value . Normalmente, você irá colocar cada definição de variável em uma linha separada. +Vamos adicionar uma variável de ambiente como uma opção de configuração. Armazene a variável MESSAGE_STYLE=uppercase no arquivo .env . Em seguida, informe ao manipulador de rota GET /json que você criou no último desafio para transformar a mensagem do objeto de resposta em maiúsculas, se process.env.MESSAGE_STYLE for igual a uppercase . O objeto de resposta deve se tornar {"message": "HELLO JSON"} . +
+ +## Instructions +
+ +
+ +## Tests +
+ +```yml +tests: + - text: A resposta do nó de extremidade /json deve mudar de acordo com a variável de ambiente MESSAGE_STYLE + testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/use-env-vars'').then(data => { assert.isTrue(data.passed, ''The response of "/json" does not change according to MESSAGE_STYLE''); }, xhr => { throw new Error(xhr.responseText); })' + +``` + +
+ +## Challenge Seed +
+ +
+ +## Solution +
+ +```js +// solution required +``` +
diff --git a/curriculum/challenges/portuguese/05-apis-and-microservices/managing-packages-with-npm/add-a-description-to-your-package.json.portuguese.md b/curriculum/challenges/portuguese/05-apis-and-microservices/managing-packages-with-npm/add-a-description-to-your-package.json.portuguese.md new file mode 100644 index 0000000000..6e703663c3 --- /dev/null +++ b/curriculum/challenges/portuguese/05-apis-and-microservices/managing-packages-with-npm/add-a-description-to-your-package.json.portuguese.md @@ -0,0 +1,47 @@ +--- +id: 587d7fb3367417b2b2512bfc +title: Add a Description to Your package.json +localeTitle: Adicione uma descrição ao seu pacote.json +challengeType: 2 +--- + +## Description +
+A próxima parte de um bom pacote.json é o campo de descrição, onde uma descrição curta, mas informativa, sobre o seu projeto pertence. +Se algum dia você planeja publicar um pacote para npm, lembre-se de que essa é a string que deve vender sua ideia ao usuário quando ele decidir se instala seu pacote ou não. No entanto, esse não é o único caso de uso para a descrição: é uma ótima maneira de resumir o que um projeto faz, tão importante para seus projetos normais do Node.js ajudar outros desenvolvedores, futuros mantenedores ou até mesmo seu futuro a entender o projeto rapidamente. +Independentemente do que você planeja para o seu projeto, uma descrição é definitivamente recomendada. Vamos adicionar algo semelhante a isto: +"description": "A project that does something awesome", +Instruções +Adicione uma descrição ao package.json em seu projeto Glitch. +Lembre-se de usar aspas duplas para nomes de campos (") e vírgulas (,) para separar campos. +
+ +## Instructions +
+ +
+ +## Tests +
+ +```yml +tests: + - text: 'package.json deve ter uma chave de "descrição" válida' + testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/package.json'').then(data => { var packJson = JSON.parse(data); assert(packJson.description, ''"description" is missing''); }, xhr => { throw new Error(xhr.responseText); })' + +``` + +
+ +## Challenge Seed +
+ +
+ +## Solution +
+ +```js +// solution required +``` +
diff --git a/curriculum/challenges/portuguese/05-apis-and-microservices/managing-packages-with-npm/add-a-license-to-your-package.json.portuguese.md b/curriculum/challenges/portuguese/05-apis-and-microservices/managing-packages-with-npm/add-a-license-to-your-package.json.portuguese.md new file mode 100644 index 0000000000..5cedbb0a43 --- /dev/null +++ b/curriculum/challenges/portuguese/05-apis-and-microservices/managing-packages-with-npm/add-a-license-to-your-package.json.portuguese.md @@ -0,0 +1,47 @@ +--- +id: 587d7fb4367417b2b2512bfe +title: Add a License to Your package.json +localeTitle: Adicione uma licença ao seu pacote.json +challengeType: 2 +--- + +## Description +
+O campo de licença é onde você informa aos usuários do seu projeto o que eles podem fazer com ele. +Algumas licenças comuns para projetos de código aberto incluem o MIT e o BSD. http://choosealicense.com é um ótimo recurso se você quiser saber mais sobre qual licença pode se encaixar em seu projeto. +Informações de licença não são necessárias. As leis de direitos autorais na maioria dos países dão a você a propriedade do que você cria por padrão. No entanto, é sempre uma boa prática declarar explicitamente o que os usuários podem e não podem fazer. +Exemplo +"license": "MIT", +Instruções +Preencha o campo de licença no package.json do seu projeto Glitch conforme achar conveniente. +
+ +## Instructions +
+ +
+ +## Tests +
+ +```yml +tests: + - text: 'package.json deve ter uma chave de "licença" válida' + testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/package.json'').then(data => { var packJson = JSON.parse(data); assert(packJson.license, ''"license" is missing''); }, xhr => { throw new Error(xhr.responseText); })' + +``` + +
+ +## Challenge Seed +
+ +
+ +## Solution +
+ +```js +// solution required +``` +
diff --git a/curriculum/challenges/portuguese/05-apis-and-microservices/managing-packages-with-npm/add-a-version-to-your-package.json.portuguese.md b/curriculum/challenges/portuguese/05-apis-and-microservices/managing-packages-with-npm/add-a-version-to-your-package.json.portuguese.md new file mode 100644 index 0000000000..7cd78a1ac9 --- /dev/null +++ b/curriculum/challenges/portuguese/05-apis-and-microservices/managing-packages-with-npm/add-a-version-to-your-package.json.portuguese.md @@ -0,0 +1,45 @@ +--- +id: 587d7fb4367417b2b2512bff +title: Add a Version to Your package.json +localeTitle: Adicione uma versão ao seu pacote.json +challengeType: 2 +--- + +## Description +
+A versão é junto com o nome de um dos campos obrigatórios em um package.json. Este campo descreve a versão atual do seu projeto. +Exemplo +"version": "1.2", +Instruções +Adicione uma versão ao pacote.json no seu projeto Glitch. +
+ +## Instructions +
+ +
+ +## Tests +
+ +```yml +tests: + - text: 'package.json deve ter uma chave "version" válida' + testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/package.json'').then(data => { var packJson = JSON.parse(data); assert(packJson.version, ''"version" is missing''); }, xhr => { throw new Error(xhr.responseText); })' + +``` + +
+ +## Challenge Seed +
+ +
+ +## Solution +
+ +```js +// solution required +``` +
diff --git a/curriculum/challenges/portuguese/05-apis-and-microservices/managing-packages-with-npm/add-keywords-to-your-package.json.portuguese.md b/curriculum/challenges/portuguese/05-apis-and-microservices/managing-packages-with-npm/add-keywords-to-your-package.json.portuguese.md new file mode 100644 index 0000000000..2715a8bae7 --- /dev/null +++ b/curriculum/challenges/portuguese/05-apis-and-microservices/managing-packages-with-npm/add-keywords-to-your-package.json.portuguese.md @@ -0,0 +1,51 @@ +--- +id: 587d7fb4367417b2b2512bfd +title: Add Keywords to Your package.json +localeTitle: Adicione palavras-chave ao seu pacote.json +challengeType: 2 +--- + +## Description +
+O campo de palavras-chave é onde você pode descrever seu projeto usando palavras-chave relacionadas. +Exemplo +"keywords": [ "descriptive", "related", "words" ], +Como você pode ver, este campo é estruturado como um array de strings com aspas duplas. +Instruções +Adicione uma matriz de strings adequadas ao campo keywords no package.json do seu projeto Glitch. +Uma das palavras-chave deve ser freecodecamp. +
+ +## Instructions +
+ +
+ +## Tests +
+ +```yml +tests: + - text: 'package.json deve ter uma chave "keywords" válida' + testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/package.json'').then(data => { var packJson = JSON.parse(data); assert(packJson.keywords, ''"keywords" is missing''); }, xhr => { throw new Error(xhr.responseText); })' + - text: 'palavras-chave campo deve ser uma matriz ' + testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/package.json'').then(data => { var packJson = JSON.parse(data); assert.isArray(packJson.keywords, ''"keywords" is not an array''); }, xhr => { throw new Error(xhr.responseText); })' + - text: '"palavras-chave" devem incluir "freecodecamp"' + testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/package.json'').then(data => { var packJson = JSON.parse(data); assert.include(packJson.keywords, ''freecodecamp'', ''"keywords" does not include "freecodecamp"''); }, xhr => { throw new Error(xhr.responseText); })' + +``` + +
+ +## Challenge Seed +
+ +
+ +## Solution +
+ +```js +// solution required +``` +
diff --git a/curriculum/challenges/portuguese/05-apis-and-microservices/managing-packages-with-npm/expand-your-project-with-external-packages-from-npm.portuguese.md b/curriculum/challenges/portuguese/05-apis-and-microservices/managing-packages-with-npm/expand-your-project-with-external-packages-from-npm.portuguese.md new file mode 100644 index 0000000000..1dc2510cb6 --- /dev/null +++ b/curriculum/challenges/portuguese/05-apis-and-microservices/managing-packages-with-npm/expand-your-project-with-external-packages-from-npm.portuguese.md @@ -0,0 +1,51 @@ +--- +id: 587d7fb4367417b2b2512c00 +title: Expand Your Project with External Packages from npm +localeTitle: Expanda seu projeto com pacotes externos do npm +challengeType: 2 +--- + +## Description +
+Um dos maiores motivos para usar um gerenciador de pacotes é seu poderoso gerenciamento de dependências. Em vez de ter que certificar-se de que você obtém todas as dependências manualmente sempre que você configura um projeto em um novo computador, o npm instala automaticamente tudo para você. Mas como pode o npm saber exatamente o que seu projeto precisa? Conheça a seção de dependências do seu package.json. +Na seção dependencies, os pacotes que o seu projeto requer são armazenados usando o seguinte formato: +"dependencies": { +"package-name": "version", +"express": "4.14.0" +} +Instruções +Adicione a versão 2.14.0 do momento do pacote ao campo dependencies do seu pacote.json +Moment é uma biblioteca útil para trabalhar com hora e datas. +
+ +## Instructions +
+ +
+ +## Tests +
+ +```yml +tests: + - text: "dependências devem incluir 'momento' " + testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/package.json'').then(data => { var packJson = JSON.parse(data); assert.property(packJson.dependencies, ''moment'', ''"dependencies" does not include "moment"''); }, xhr => { throw new Error(xhr.responseText); })' + - text: 'A versão "momento" deve ser "2.14.0"' + testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/package.json'').then(data => { var packJson = JSON.parse(data); assert.match(packJson.dependencies.moment, /^[\^\~]?2\.14\.0/, ''Wrong version of "moment" installed. It should be 2.14.0''); }, xhr => { throw new Error(xhr.responseText); })' + +``` + +
+ +## Challenge Seed +
+ +
+ +## Solution +
+ +```js +// solution required +``` +
diff --git a/curriculum/challenges/portuguese/05-apis-and-microservices/managing-packages-with-npm/how-to-use-package.json-the-core-of-any-node.js-project-or-npm-package.portuguese.md b/curriculum/challenges/portuguese/05-apis-and-microservices/managing-packages-with-npm/how-to-use-package.json-the-core-of-any-node.js-project-or-npm-package.portuguese.md new file mode 100644 index 0000000000..805306a0f8 --- /dev/null +++ b/curriculum/challenges/portuguese/05-apis-and-microservices/managing-packages-with-npm/how-to-use-package.json-the-core-of-any-node.js-project-or-npm-package.portuguese.md @@ -0,0 +1,50 @@ +--- +id: 587d7fb3367417b2b2512bfb +title: 'How to Use package.json, the Core of Any Node.js Project or npm Package' +localeTitle: 'Como usar o package.json, o Core de qualquer projeto Node.js ou npm Package' +challengeType: 2 +--- + +## Description +
+O arquivo package.json é o centro de qualquer projeto Node.js ou pacote npm. Ele armazena informações sobre seu projeto da mesma forma que a seção <head> em um documento HTML descreve o conteúdo de uma página da Web. O pacote.json consiste em um único objeto JSON, onde as informações são armazenadas em "chave": pares de valores. Existem apenas dois campos obrigatórios em um pacote mínimo.json - nome e versão - mas é uma boa prática fornecer informações adicionais sobre o seu projeto que podem ser úteis para futuros usuários ou mantenedores. +O autor-campo +Se você for ao projeto Glitch que você configurou anteriormente e olhar no lado esquerdo da sua tela, você encontrará a árvore de arquivos onde você pode ver uma visão geral dos vários arquivos em seu projeto. Sob a seção de back-end da árvore de arquivos, você encontrará o pacote.json - o arquivo que estaremos aprimorando nos próximos desafios. +Uma das informações mais comuns neste arquivo é o autor-campo que especifica quem é o criador de um projeto. Pode ser uma string ou um objeto com detalhes de contato. O objeto é recomendado para projetos maiores, mas no nosso caso, uma string simples como o exemplo a seguir serve. +"author": "Jane Doe", +Instruções +Adicione seu nome ao autor-campo no package.json do seu projeto Glitch. +Lembre-se que você está escrevendo JSON. +Todos os nomes de campos devem usar aspas duplas ("), por exemplo," autor " +Todos os campos devem ser separados por uma vírgula (,) +
+ +## Instructions +
+ +
+ +## Tests +
+ +```yml +tests: + - text: 'package.json deve ter uma chave "author" válida' + testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/package.json'').then(data => { var packJson = JSON.parse(data); assert(packJson.author, ''"author" is missing''); }, xhr => { throw new Error(xhr.responseText); })' + +``` + +
+ +## Challenge Seed +
+ +
+ +## Solution +
+ +```js +// solution required +``` +
diff --git a/curriculum/challenges/portuguese/05-apis-and-microservices/managing-packages-with-npm/manage-npm-dependencies-by-understanding-semantic-versioning.portuguese.md b/curriculum/challenges/portuguese/05-apis-and-microservices/managing-packages-with-npm/manage-npm-dependencies-by-understanding-semantic-versioning.portuguese.md new file mode 100644 index 0000000000..e5b6f21956 --- /dev/null +++ b/curriculum/challenges/portuguese/05-apis-and-microservices/managing-packages-with-npm/manage-npm-dependencies-by-understanding-semantic-versioning.portuguese.md @@ -0,0 +1,56 @@ +--- +id: 587d7fb5367417b2b2512c01 +title: Manage npm Dependencies By Understanding Semantic Versioning +localeTitle: Gerenciar Dependências do npm Entendendo o Versionamento Semântico +challengeType: 2 +--- + +## Description +
+Versões dos pacotes npm na seção de dependências do seu package.json seguem o que é chamado de Semântica, um padrão da indústria para versionamento de software com o objetivo de facilitar o gerenciamento de dependências. Bibliotecas, estruturas ou outras ferramentas publicadas no npm devem usar o SemVer para comunicar claramente que tipo de mudanças os projetos que dependem do pacote podem esperar se atualizarem. +SemVer não faz sentido em projetos sem APIs públicas - portanto, a menos que seu projeto seja semelhante aos exemplos acima, use outro formato de versão. +Então, por que você precisa entender a SemVer? +Saber SemVer pode ser útil quando você desenvolve softwares que usam dependências externas (o que você quase sempre faz). Um dia, a sua compreensão desses números evitará que você introduza acidentalmente alterações inesperadas em seu projeto sem entender por que as coisas “que funcionaram ontem” de repente não o fazem. +É assim que o Versioning Semântico funciona de acordo com o site oficial: +Dado um número de versão MAJOR.MINOR.PATCH, incremente a: +versão MAJOR quando você faz alterações incompatíveis de API, versão +MINOR quando adiciona funcionalidade de maneira compatível com versões anteriores e +versão PATCH quando você faz correções de bugs compatíveis com versões anteriores. +Isso significa que os PATCHES são correções de bugs e os MINORs adicionam novos recursos, mas nenhum deles quebra o que funcionou antes. Finalmente, os MAJORs adicionam alterações que não funcionam com versões anteriores. +Exemplo +Um número de versão semântica: 1.3.8 +Instruções +Na seção dependencies do seu pacote.json, altere a versão do momento para coincidir com MAJOR versão 2, MINOR versão 10 e PATCH versão 2 +
+ +## Instructions +
+ +
+ +## Tests +
+ +```yml +tests: + - text: "dependências devem incluir 'momento' " + testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/package.json'').then(data => { var packJson = JSON.parse(data); assert.property(packJson.dependencies, ''moment'', ''"dependencies" does not include "moment"''); }, xhr => { throw new Error(xhr.responseText); })' + - text: 'A versão "momento" deve ser "2.10.2" ' + testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/package.json'').then(data => { var packJson = JSON.parse(data); assert.match(packJson.dependencies.moment, /^[\^\~]?2\.10\.2/, ''Wrong version of "moment". It should be 2.10.2''); }, xhr => { throw new Error(xhr.responseText); })' + +``` + +
+ +## Challenge Seed +
+ +
+ +## Solution +
+ +```js +// solution required +``` +
diff --git a/curriculum/challenges/portuguese/05-apis-and-microservices/managing-packages-with-npm/remove-a-package-from-your-dependencies.portuguese.md b/curriculum/challenges/portuguese/05-apis-and-microservices/managing-packages-with-npm/remove-a-package-from-your-dependencies.portuguese.md new file mode 100644 index 0000000000..1520ee84ba --- /dev/null +++ b/curriculum/challenges/portuguese/05-apis-and-microservices/managing-packages-with-npm/remove-a-package-from-your-dependencies.portuguese.md @@ -0,0 +1,46 @@ +--- +id: 587d7fb5367417b2b2512c04 +title: Remove a Package from Your Dependencies +localeTitle: Remover um pacote de suas dependências +challengeType: 2 +--- + +## Description +
+Agora você testou algumas maneiras de gerenciar dependências do seu projeto usando a seção de dependências do package.json. Você incluiu pacotes externos adicionando-os ao arquivo e até informou ao npm que tipos de versões você deseja usando caracteres especiais como o til (~) ou o cursor (^). +Mas e se você quiser remover um pacote externo que não precisa mais? Você já deve ter adivinhado - Apenas remova a "chave" correspondente: par de valores para isso de suas dependências. +Esse mesmo método se aplica à remoção de outros campos no seu package.json também +Instruções +Remova o momento do pacote de suas dependências. +Verifique se você tem a quantidade certa de vírgulas depois de removê-lo. +
+ +## Instructions +
+ +
+ +## Tests +
+ +```yml +tests: + - text: "'dependências' não devem incluir 'momento' " + testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/package.json'').then(data => { var packJson = JSON.parse(data); assert.notProperty(packJson.dependencies, ''moment'', ''"dependencies" still includes "moment"''); }, xhr => { throw new Error(xhr.responseText); })' + +``` + +
+ +## Challenge Seed +
+ +
+ +## Solution +
+ +```js +// solution required +``` +
diff --git a/curriculum/challenges/portuguese/05-apis-and-microservices/managing-packages-with-npm/use-the-caret-character-to-use-the-latest-minor-version-of-a-dependency.portuguese.md b/curriculum/challenges/portuguese/05-apis-and-microservices/managing-packages-with-npm/use-the-caret-character-to-use-the-latest-minor-version-of-a-dependency.portuguese.md new file mode 100644 index 0000000000..5c57141ce0 --- /dev/null +++ b/curriculum/challenges/portuguese/05-apis-and-microservices/managing-packages-with-npm/use-the-caret-character-to-use-the-latest-minor-version-of-a-dependency.portuguese.md @@ -0,0 +1,49 @@ +--- +id: 587d7fb5367417b2b2512c03 +title: Use the Caret-Character to Use the Latest Minor Version of a Dependency +localeTitle: Use o Caret Caret para usar a última versão menor de uma dependência +challengeType: 2 +--- + +## Description +
+Semelhante ao modo como o til (~) que aprendemos no último desafio permite que o npm instale o último PATCH para uma dependência, o cursor (^) também permite que o npm instale atualizações futuras. A diferença é que o cursor permite tanto atualizações MINORIS quanto PATCHES. +No momento, sua versão atual do momento deve ser ~ 2.10.2, que permite que o npm seja instalado na última versão 2.10.x. Se, em vez disso, usássemos o cursor (^) como nosso prefixo de versão, o npm teria permissão para atualizar para qualquer versão 2.xx. +Exemplo +"some-package-name": "^1.3.8" allows updates to any 1.xx version. +Instruções +Use o caractere de interpolação (^) para prefixar a versão do momento em suas dependências e permitir que o npm a atualize para qualquer nova versão MINOR. +Observe que os números da versão não devem ser alterados. +
+ +## Instructions +
+ +
+ +## Tests +
+ +```yml +tests: + - text: "'dependências' devem incluir 'momento' " + testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/package.json'').then(data => { var packJson = JSON.parse(data); assert.property(packJson.dependencies, ''moment'', ''"dependencies" does not include "moment"''); }, xhr => { throw new Error(xhr.responseText); })' + - text: 'A versão "momento" deve corresponder a "^ 2.x.x" ' + testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/package.json'').then(data => { var packJson = JSON.parse(data); assert.match(packJson.dependencies.moment, /^\^2\./, ''Wrong version of "moment". It should be ^2.10.2''); }, xhr => { throw new Error(xhr.responseText); })' + +``` + +
+ +## Challenge Seed +
+ +
+ +## Solution +
+ +```js +// solution required +``` +
diff --git a/curriculum/challenges/portuguese/05-apis-and-microservices/managing-packages-with-npm/use-the-tilde-character-to-always-use-the-latest-patch-version-of-a-dependency.portuguese.md b/curriculum/challenges/portuguese/05-apis-and-microservices/managing-packages-with-npm/use-the-tilde-character-to-always-use-the-latest-patch-version-of-a-dependency.portuguese.md new file mode 100644 index 0000000000..2f9a2359da --- /dev/null +++ b/curriculum/challenges/portuguese/05-apis-and-microservices/managing-packages-with-npm/use-the-tilde-character-to-always-use-the-latest-patch-version-of-a-dependency.portuguese.md @@ -0,0 +1,49 @@ +--- +id: 587d7fb5367417b2b2512c02 +title: Use the Tilde-Character to Always Use the Latest Patch Version of a Dependency +localeTitle: Use o caractere Tilde para sempre usar a versão de patch mais recente de uma dependência +challengeType: 2 +--- + +## Description +
+No último desafio, dissemos ao npm para incluir apenas uma versão específica de um pacote. Essa é uma maneira útil de congelar suas dependências se você precisar garantir que partes diferentes do seu projeto permaneçam compatíveis umas com as outras. Mas, na maioria dos casos de uso, você não quer perder correções de bugs, pois elas geralmente incluem patches de segurança importantes e (espero) não quebram as coisas ao fazê-lo. +Para permitir que uma dependência npm seja atualizada para a versão PATCH mais recente, você pode prefixar a versão da dependência com o caractere til (~). Em package.json, nossa regra atual de como o npm pode atualizar o momento é usar apenas uma versão específica (2.10.2), mas queremos permitir a última versão 2.10.x. +Exemplo +"some-package-name": "~1.3.8" allows updates to any 1.3.x version. +Instruções +Use o til (~) para prefixar a versão do momento em suas dependências e permitir que o npm o atualize para qualquer nova versão do PATCH. +Observe que os números da versão não devem ser alterados. +
+ +## Instructions +
+ +
+ +## Tests +
+ +```yml +tests: + - text: "'dependências' devem incluir 'momento' " + testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/package.json'').then(data => { var packJson = JSON.parse(data); assert.property(packJson.dependencies, ''moment'', ''"dependencies" does not include "moment"''); }, xhr => { throw new Error(xhr.responseText); })' + - text: 'A versão "momento" deve corresponder a "~ 2.10.2" ' + testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/package.json'').then(data => { var packJson = JSON.parse(data); assert.match(packJson.dependencies.moment, /^\~2\.10\.2/, ''Wrong version of "moment". It should be ~2.10.2''); }, xhr => { throw new Error(xhr.responseText); })' + +``` + +
+ +## Challenge Seed +
+ +
+ +## Solution +
+ +```js +// solution required +``` +
diff --git a/curriculum/challenges/portuguese/05-apis-and-microservices/mongodb-and-mongoose/chain-search-query-helpers-to-narrow-search-results.portuguese.md b/curriculum/challenges/portuguese/05-apis-and-microservices/mongodb-and-mongoose/chain-search-query-helpers-to-narrow-search-results.portuguese.md new file mode 100644 index 0000000000..b12363263c --- /dev/null +++ b/curriculum/challenges/portuguese/05-apis-and-microservices/mongodb-and-mongoose/chain-search-query-helpers-to-narrow-search-results.portuguese.md @@ -0,0 +1,42 @@ +--- +id: 587d7fb9367417b2b2512c12 +title: Chain Search Query Helpers to Narrow Search Results +localeTitle: Auxiliares de consulta de pesquisa em cadeia para restringir os resultados da pesquisa +challengeType: 2 +--- + +## Description +
+Se você não passar o retorno de chamada como o último argumento para Model.find () (ou para os outros métodos de pesquisa), a consulta não será executada. Você pode armazenar a consulta em uma variável para uso posterior. Esse tipo de objeto permite que você crie uma consulta usando a sintaxe de encadeamento. A pesquisa real do banco de dados é executada quando você encadeia o método .exec (). Passe seu retorno de chamada para este último método. Existem muitos helpers de consulta, aqui usaremos os mais "famosos". +Encontre pessoas que gostam de "burrito". Ordena-os pelo nome, limita os resultados a dois documentos e oculta a idade. Cadeia .find (), .sort (), .limit (), .select () e, em seguida, .exec (). Passe o retorno de chamada concluído (err, data) para exec (). +
+ +## Instructions +
+ +
+ +## Tests +
+ +```yml +tests: + - text: Encadeamento de helpers de consulta deve ser bem-sucedido + testString: 'getUserInput => $.ajax({url: getUserInput(''url'') + ''/_api/query-tools'', type: ''POST'', contentType:''application/json'', data: JSON.stringify([{name: ''Pablo'', age: 26, favoriteFoods: [''burrito'', ''hot-dog'']}, {name: ''Bob'', age: 23, favoriteFoods: [''pizza'', ''nachos'']}, {name: ''Ashley'', age: 32, favoriteFoods: [''steak'', ''burrito'']}, {name: ''Mario'', age: 51, favoriteFoods: [''burrito'', ''prosciutto'']} ]) }).then(data => { assert.isArray(data, ''the response should be an Array''); assert.equal(data.length, 2, ''the data array length is not what expected''); assert.notProperty(data[0], ''age'', ''The returned first item has too many properties''); assert.equal(data[0].name, ''Ashley'', ''The returned first item name is not what expected''); assert.notProperty(data[1], ''age'', ''The returned second item has too many properties''); assert.equal(data[1].name, ''Mario'', ''The returned second item name is not what expected'');}, xhr => { throw new Error(xhr.responseText); })' + +``` + +
+ +## Challenge Seed +
+ +
+ +## Solution +
+ +```js +// solution required +``` +
diff --git a/curriculum/challenges/portuguese/05-apis-and-microservices/mongodb-and-mongoose/create-a-model.portuguese.md b/curriculum/challenges/portuguese/05-apis-and-microservices/mongodb-and-mongoose/create-a-model.portuguese.md new file mode 100644 index 0000000000..68b5ca2e49 --- /dev/null +++ b/curriculum/challenges/portuguese/05-apis-and-microservices/mongodb-and-mongoose/create-a-model.portuguese.md @@ -0,0 +1,61 @@ +--- +id: 587d7fb6367417b2b2512c07 +title: Create a Model +localeTitle: Crie um modelo +challengeType: 2 +--- + +## Description +
+Primeiro de tudo, precisamos de um esquema. Cada esquema mapeia para uma coleção do MongoDB. Ele define a forma dos documentos dentro dessa coleção. +Esquemas são blocos de construção para modelos. Eles podem ser aninhados para criar modelos complexos, mas, nesse caso, manteremos as coisas simples. +Um modelo permite criar instâncias de seus objetos, chamados documentos. +Crie uma pessoa com este protótipo: +- Person Prototype - +-------------------- +name : string [required] +age : number +favoriteFoods : array of strings (*) +Use os tipos básicos de esquema do mangusto. Se desejar, você também pode adicionar mais +campos, usar validadores simples, como obrigatório ou exclusivo, +e definir valores padrão. Veja o mangusto docs . +[C] RUD Parte I - CREATE +Nota: Glitch é um servidor real, e em servidores reais as interações com o banco de dados acontecem nas funções do manipulador. Essas funções são executadas quando algum evento acontece (por exemplo, alguém atinge um endpoint em sua API). Vamos seguir a mesma abordagem nesses exercícios. A função done () é um retorno de chamada que nos informa que podemos prosseguir após concluir uma operação assíncrona, como inserir, pesquisar, atualizar ou excluir. Está seguindo a convenção do Nó e deve ser chamado como concluído (nulo, dados) em sucesso, ou concluído (err) em erro. +Aviso - Ao interagir com serviços remotos, podem ocorrer erros! +/* Example */ +var someFunc = function(done) { +//... do something (risky) ... +if(error) return done(error); +done(null, result); +}; +
+ +## Instructions +
+ +
+ +## Tests +
+ +```yml +tests: + - text: Criar uma instância de um esquema de mongoose deve ser bem-sucedido + testString: 'getUserInput => $.post(getUserInput(''url'') + ''/_api/mongoose-model'', {name: ''Mike'', age: 28, favoriteFoods: [''pizza'', ''cheese'']}).then(data => { assert.equal(data.name, ''Mike'', ''"model.name" is not what expected''); assert.equal(data.age, ''28'', ''"model.age" is not what expected''); assert.isArray(data.favoriteFoods, ''"model.favoriteFoods" is not an Array''); assert.include(data.favoriteFoods, ''pizza'', ''"model.favoriteFoods" does not include the expected items''); assert.include(data.favoriteFoods, ''cheese'', ''"model.favoriteFoods" does not include the expected items''); }, xhr => { throw new Error(xhr.responseText); })' + +``` + +
+ +## Challenge Seed +
+ +
+ +## Solution +
+ +```js +// solution required +``` +
diff --git a/curriculum/challenges/portuguese/05-apis-and-microservices/mongodb-and-mongoose/create-and-save-a-record-of-a-model.portuguese.md b/curriculum/challenges/portuguese/05-apis-and-microservices/mongodb-and-mongoose/create-and-save-a-record-of-a-model.portuguese.md new file mode 100644 index 0000000000..cd4e00cc98 --- /dev/null +++ b/curriculum/challenges/portuguese/05-apis-and-microservices/mongodb-and-mongoose/create-and-save-a-record-of-a-model.portuguese.md @@ -0,0 +1,46 @@ +--- +id: 587d7fb6367417b2b2512c09 +title: Create and Save a Record of a Model +localeTitle: Criar e salvar um registro de um modelo +challengeType: 2 +--- + +## Description +
+Crie uma instância de documento usando o construtor Person que você construiu antes. Passe para o construtor um objeto com os campos name, age e favoriteFoods. Seus tipos devem estar em conformidade com os do esquema pessoal. Em seguida, chame o método document.save () na instância do documento retornado. Passe para ele um retorno de chamada usando a convenção Node. Esse é um padrão comum, todos os métodos CRUD a seguir assumem uma função de retorno de chamada como o último argumento. +/* Example */ +// ... +person.save(function(err, data) { +// ...do your stuff here... +}); +
+ +## Instructions +
+ +
+ +## Tests +
+ +```yml +tests: + - text: Criar e salvar um item do banco de dados deve ser bem-sucedido + testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/create-and-save-person'').then(data => { assert.isString(data.name, ''"item.name" should be a String''); assert.isNumber(data.age, ''28'', ''"item.age" should be a Number''); assert.isArray(data.favoriteFoods, ''"item.favoriteFoods" should be an Array''); assert.equal(data.__v, 0, ''The db item should be not previously edited''); }, xhr => { throw new Error(xhr.responseText); })' + +``` + +
+ +## Challenge Seed +
+ +
+ +## Solution +
+ +```js +// solution required +``` +
diff --git a/curriculum/challenges/portuguese/05-apis-and-microservices/mongodb-and-mongoose/create-many-records-with-model.create.portuguese.md b/curriculum/challenges/portuguese/05-apis-and-microservices/mongodb-and-mongoose/create-many-records-with-model.create.portuguese.md new file mode 100644 index 0000000000..cf5eb24d17 --- /dev/null +++ b/curriculum/challenges/portuguese/05-apis-and-microservices/mongodb-and-mongoose/create-many-records-with-model.create.portuguese.md @@ -0,0 +1,41 @@ +--- +id: 587d7fb7367417b2b2512c0a +title: Create Many Records with model.create() +localeTitle: Crie muitos registros com model.create () +challengeType: 2 +--- + +## Description +
+Às vezes, você precisa criar muitas instâncias de seus modelos, por exemplo, ao criar um banco de dados com dados iniciais. Model.create () pega uma matriz de objetos como [{name: 'John', ...}, {...}, ...] como o primeiro argumento e salva todos eles no banco de dados. Crie muitas pessoas com Model.create (), usando o argumento da função arrayOfPeople. +
+ +## Instructions +
+ +
+ +## Tests +
+ +```yml +tests: + - text: Criar muitos itens de banco de dados de uma só vez deve ser bem-sucedido + testString: 'getUserInput => $.ajax({url: getUserInput(''url'') + ''/_api/create-many-people'', type: ''POST'', contentType:''application/json'', data: JSON.stringify([{name: ''John'', age: 24, favoriteFoods: [''pizza'', ''salad'']}, {name: ''Mary'', age: 21, favoriteFoods: [''onions'', ''chicken'']}])}).then(data => { assert.isArray(data, ''the response should be an array''); assert.equal(data.length, 2, ''the response does not contain the expected number of items''); assert.equal(data[0].name, ''John'', ''The first item is not correct''); assert.equal(data[0].__v, 0, ''The first item should be not previously edited''); assert.equal(data[1].name, ''Mary'', ''The second item is not correct''); assert.equal(data[1].__v, 0, ''The second item should be not previously edited''); }, xhr => { throw new Error(xhr.responseText); })' + +``` + +
+ +## Challenge Seed +
+ +
+ +## Solution +
+ +```js +// solution required +``` +
diff --git a/curriculum/challenges/portuguese/05-apis-and-microservices/mongodb-and-mongoose/delete-many-documents-with-model.remove.portuguese.md b/curriculum/challenges/portuguese/05-apis-and-microservices/mongodb-and-mongoose/delete-many-documents-with-model.remove.portuguese.md new file mode 100644 index 0000000000..f104b48ebe --- /dev/null +++ b/curriculum/challenges/portuguese/05-apis-and-microservices/mongodb-and-mongoose/delete-many-documents-with-model.remove.portuguese.md @@ -0,0 +1,42 @@ +--- +id: 587d7fb8367417b2b2512c11 +title: Delete Many Documents with model.remove() +localeTitle: Excluir muitos documentos com model.remove () +challengeType: 2 +--- + +## Description +
+Model.remove () é útil para excluir todos os documentos que correspondem a determinados critérios. Exclua todas as pessoas cujo nome é "Mary", usando Model.remove (). Passe-o para um documento de consulta com o conjunto de campos “nome” e, claro, um retorno de chamada. +Nota: Model.remove () não retorna o documento excluído, mas um objeto JSON contendo o resultado da operação e o número de itens afetados. Não esqueça de passá-lo para o callback done (), já que o usamos em testes. +
+ +## Instructions +
+ +
+ +## Tests +
+ +```yml +tests: + - text: A exclusão de muitos itens de uma só vez deve ser bem-sucedida + testString: 'getUserInput => $.ajax({url: getUserInput(''url'') + ''/_api/remove-many-people'', type: ''POST'', contentType:''application/json'', data: JSON.stringify([{name: ''Mary'', age: 16, favoriteFoods: [''lollipop'']}, {name: ''Mary'', age: 21, favoriteFoods: [''steak'']}])}).then(data => { assert.isTrue(!!data.ok, ''The mongo stats are not what expected''); assert.equal(data.n, 2, ''The number of items affected is not what expected''); assert.equal(data.count, 0, ''the db items count is not what expected''); }, xhr => { throw new Error(xhr.responseText); })' + +``` + +
+ +## Challenge Seed +
+ +
+ +## Solution +
+ +```js +// solution required +``` +
diff --git a/curriculum/challenges/portuguese/05-apis-and-microservices/mongodb-and-mongoose/delete-one-document-using-model.findbyidandremove.portuguese.md b/curriculum/challenges/portuguese/05-apis-and-microservices/mongodb-and-mongoose/delete-one-document-using-model.findbyidandremove.portuguese.md new file mode 100644 index 0000000000..3d9d076d97 --- /dev/null +++ b/curriculum/challenges/portuguese/05-apis-and-microservices/mongodb-and-mongoose/delete-one-document-using-model.findbyidandremove.portuguese.md @@ -0,0 +1,41 @@ +--- +id: 587d7fb8367417b2b2512c10 +title: Delete One Document Using model.findByIdAndRemove +localeTitle: Excluir um documento usando model.findByIdAndRemove +challengeType: 2 +--- + +## Description +
+Excluir uma pessoa por ela _id. Você deve usar um dos métodos findByIdAndRemove () ou findOneAndRemove (). Eles são como os métodos de atualização anteriores. Eles passam o documento removido para o cb. Como de costume, use o argumento da função personId como chave de busca. +
+ +## Instructions +
+ +
+ +## Tests +
+ +```yml +tests: + - text: A exclusão de um item deve ser bem-sucedida + testString: 'getUserInput => $.post(getUserInput(''url'') + ''/_api/remove-one-person'', {name:''Jason Bourne'', age: 36, favoriteFoods:[''apples'']}).then(data => { assert.equal(data.name, ''Jason Bourne'', ''item.name is not what expected''); assert.equal(data.age, 36, ''item.age is not what expected''); assert.deepEqual(data.favoriteFoods, [''apples''], ''item.favoriteFoods is not what expected''); assert.equal(data.__v, 0); assert.equal(data.count, 0, ''the db items count is not what expected''); }, xhr => { throw new Error(xhr.responseText); })' + +``` + +
+ +## Challenge Seed +
+ +
+ +## Solution +
+ +```js +// solution required +``` +
diff --git a/curriculum/challenges/portuguese/05-apis-and-microservices/mongodb-and-mongoose/install-and-set-up-mongoose.portuguese.md b/curriculum/challenges/portuguese/05-apis-and-microservices/mongodb-and-mongoose/install-and-set-up-mongoose.portuguese.md new file mode 100644 index 0000000000..c937eccf8d --- /dev/null +++ b/curriculum/challenges/portuguese/05-apis-and-microservices/mongodb-and-mongoose/install-and-set-up-mongoose.portuguese.md @@ -0,0 +1,45 @@ +--- +id: 587d7fb6367417b2b2512c06 +title: Install and Set Up Mongoose +localeTitle: Instalar e configurar o mangusto +challengeType: 2 +--- + +## Description +
+Adicione mongodb e mangusto ao package.json do projeto. Então exija mangusto. Armazene seu URI do banco de dados mLab no arquivo .env privado como MONGO_URI. Conecte-se ao banco de dados usando mongoose.connect ( ) +
+ +## Instructions +
+ +
+ +## Tests +
+ +```yml +tests: + - text: "'mongodb' dependência deve estar em package.json" + testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/file/package.json'').then(data => { var packJson = JSON.parse(data); assert.property(packJson.dependencies, ''mongodb''); }, xhr => { throw new Error(xhr.responseText); })' + - text: "'mongoose' dependência deve estar em package.json" + testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/file/package.json'').then(data => { var packJson = JSON.parse(data); assert.property(packJson.dependencies, ''mongoose''); }, xhr => { throw new Error(xhr.responseText); })' + - text: "'mangusto' deve ser conectado a um banco de dados" + testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/is-mongoose-ok'').then(data => {assert.isTrue(data.isMongooseOk, ''mongoose is not connected'')}, xhr => { throw new Error(xhr.responseText); })' + +``` + +
+ +## Challenge Seed +
+ +
+ +## Solution +
+ +```js +// solution required +``` +
diff --git a/curriculum/challenges/portuguese/05-apis-and-microservices/mongodb-and-mongoose/perform-classic-updates-by-running-find-edit-then-save.portuguese.md b/curriculum/challenges/portuguese/05-apis-and-microservices/mongodb-and-mongoose/perform-classic-updates-by-running-find-edit-then-save.portuguese.md new file mode 100644 index 0000000000..2663f7ea4f --- /dev/null +++ b/curriculum/challenges/portuguese/05-apis-and-microservices/mongodb-and-mongoose/perform-classic-updates-by-running-find-edit-then-save.portuguese.md @@ -0,0 +1,43 @@ +--- +id: 587d7fb8367417b2b2512c0e +title: 'Perform Classic Updates by Running Find, Edit, then Save' +localeTitle: 'Executar atualizações clássicas executando Localizar, editar e salvar' +challengeType: 2 +--- + +## Description +
+Nos bons e velhos tempos isso era o que você precisava fazer se quisesse editar um documento e ser capaz de usá-lo de alguma forma, por exemplo, enviando-o de volta em uma resposta do servidor. O Mongoose possui um método de atualização dedicado: Model.update (). Ele é vinculado ao driver mongo de baixo nível. Ele pode editar em massa muitos documentos que atendem a determinados critérios, mas não envia de volta o documento atualizado, apenas uma mensagem de 'status'. Além disso, dificulta a validação de modelos, porque apenas chama diretamente o driver mongo. +Encontre uma pessoa por _id (use qualquer um dos métodos acima) com o parâmetro personId como chave de busca. Adicione "hamburger" à lista de seus favoriteFoods (você pode usar Array.push ()). Então - dentro do callback de busca - salve () a Pessoa atualizada. +[*] Dica: Isso pode ser complicado se no seu Schema você declarar favoriteFoods como Array, sem especificar o tipo (ie [String]). Em que casefavoriteFoods padrão para o tipo misto, e você tem que marcá-lo manualmente como editado usando document.markModified ('edited-field'). (http://mongoosejs.com/docs/schematypes.html - #Mixed) +
+ +## Instructions +
+ +
+ +## Tests +
+ +```yml +tests: + - text: Localizar-editar-atualizar um item deve ser bem-sucedido + testString: 'getUserInput => $.post(getUserInput(''url'') + ''/_api/find-edit-save'', {name:''Poldo'', age: 40, favoriteFoods:[''spaghetti'']}).then(data => { assert.equal(data.name, ''Poldo'', ''item.name is not what expected''); assert.equal(data.age, 40, ''item.age is not what expected''); assert.deepEqual(data.favoriteFoods, [''spaghetti'', ''hamburger''], ''item.favoriteFoods is not what expected''); assert.equal(data.__v, 1, ''The item should be previously edited''); }, xhr => { throw new Error(xhr.responseText); })' + +``` + +
+ +## Challenge Seed +
+ +
+ +## Solution +
+ +```js +// solution required +``` +
diff --git a/curriculum/challenges/portuguese/05-apis-and-microservices/mongodb-and-mongoose/perform-new-updates-on-a-document-using-model.findoneandupdate.portuguese.md b/curriculum/challenges/portuguese/05-apis-and-microservices/mongodb-and-mongoose/perform-new-updates-on-a-document-using-model.findoneandupdate.portuguese.md new file mode 100644 index 0000000000..4f90a04a43 --- /dev/null +++ b/curriculum/challenges/portuguese/05-apis-and-microservices/mongodb-and-mongoose/perform-new-updates-on-a-document-using-model.findoneandupdate.portuguese.md @@ -0,0 +1,43 @@ +--- +id: 587d7fb8367417b2b2512c0f +title: Perform New Updates on a Document Using model.findOneAndUpdate() +localeTitle: Executar novas atualizações em um documento usando model.findOneAndUpdate () +challengeType: 2 +--- + +## Description +
+Versões recentes do mongoose possuem métodos para simplificar a atualização de documentos. Alguns recursos mais avançados (isto é, ganchos de pré / pós, validação) se comportam de maneira diferente com essa abordagem, portanto, o método Clássico ainda é útil em muitas situações. findByIdAndUpdate () pode ser usado ao pesquisar por Id. +Encontre uma pessoa por Nome e defina sua idade como 20. Use o parâmetro de função personName como chave de pesquisa. +Dica: queremos que você devolva o documento atualizado. Para fazer isso, você precisa passar o documento de opções {new: true} como o terceiro argumento para findOneAndUpdate (). Por padrão, esses métodos retornam o objeto não modificado. +
+ +## Instructions +
+ +
+ +## Tests +
+ +```yml +tests: + - text: findOneAndUpdate um item deve ter sucesso + testString: 'getUserInput => $.post(getUserInput(''url'') + ''/_api/find-one-update'', {name:''Dorian Gray'', age: 35, favoriteFoods:[''unknown'']}).then(data => { assert.equal(data.name, ''Dorian Gray'', ''item.name is not what expected''); assert.equal(data.age, 20, ''item.age is not what expected''); assert.deepEqual(data.favoriteFoods, [''unknown''], ''item.favoriteFoods is not what expected''); assert.equal(data.__v, 0, ''findOneAndUpdate does not increment version by design !!!''); }, xhr => { throw new Error(xhr.responseText); })' + +``` + +
+ +## Challenge Seed +
+ +
+ +## Solution +
+ +```js +// solution required +``` +
diff --git a/curriculum/challenges/portuguese/05-apis-and-microservices/mongodb-and-mongoose/use-model.find-to-search-your-database.portuguese.md b/curriculum/challenges/portuguese/05-apis-and-microservices/mongodb-and-mongoose/use-model.find-to-search-your-database.portuguese.md new file mode 100644 index 0000000000..a1d8dfe627 --- /dev/null +++ b/curriculum/challenges/portuguese/05-apis-and-microservices/mongodb-and-mongoose/use-model.find-to-search-your-database.portuguese.md @@ -0,0 +1,42 @@ +--- +id: 587d7fb7367417b2b2512c0b +title: Use model.find() to Search Your Database +localeTitle: Use model.find () para pesquisar seu banco de dados +challengeType: 2 +--- + +## Description +
+Encontre todas as pessoas que possuem um determinado nome, usando Model.find () -> [Person] +Em seu uso mais simples, Model.find () aceita um documento de consulta (um objeto JSON) como o primeiro argumento e, em seguida, um retorno de chamada. Ele retorna uma matriz de correspondências. Suporta uma gama extremamente ampla de opções de pesquisa. Verifique nos documentos. Use o argumento de função personName como chave de pesquisa. +
+ +## Instructions +
+ +
+ +## Tests +
+ +```yml +tests: + - text: Encontrar todos os itens correspondentes a um critério devem ser bem sucedidos + testString: 'getUserInput => $.post(getUserInput(''url'') + ''/_api/find-all-by-name'', {name: ''r@nd0mN4m3'', age: 24, favoriteFoods: [''pizza'']}).then(data => { assert.isArray(data, ''the response should be an Array''); assert.equal(data[0].name, ''r@nd0mN4m3'', ''item.name is not what expected''); assert.equal(data[0].__v, 0, ''The item should be not previously edited''); }, xhr => { throw new Error(xhr.responseText); })' + +``` + +
+ +## Challenge Seed +
+ +
+ +## Solution +
+ +```js +// solution required +``` +
diff --git a/curriculum/challenges/portuguese/05-apis-and-microservices/mongodb-and-mongoose/use-model.findbyid-to-search-your-database-by-id.portuguese.md b/curriculum/challenges/portuguese/05-apis-and-microservices/mongodb-and-mongoose/use-model.findbyid-to-search-your-database-by-id.portuguese.md new file mode 100644 index 0000000000..9d134fb061 --- /dev/null +++ b/curriculum/challenges/portuguese/05-apis-and-microservices/mongodb-and-mongoose/use-model.findbyid-to-search-your-database-by-id.portuguese.md @@ -0,0 +1,41 @@ +--- +id: 587d7fb7367417b2b2512c0d +title: Use model.findById() to Search Your Database By _id +localeTitle: Use model.findById () para pesquisar seu banco de dados por _id +challengeType: 2 +--- + +## Description +
+Ao salvar um documento, o mongodb adiciona automaticamente o campo _id e o configura para uma chave alfanumérica exclusiva. Pesquisar por _id é uma operação extremamente frequente, então o mangusto fornece um método dedicado para isso. Encontre a pessoa (somente !!) tendo um determinado _id, usando Model.findById () -> Person. Use o argumento da função personId como chave de busca. +
+ +## Instructions +
+ +
+ +## Tests +
+ +```yml +tests: + - text: Encontrar um item por Id deve ter sucesso + testString: 'getUserInput => $.get(getUserInput(''url'') + ''/_api/find-by-id'').then(data => { assert.equal(data.name, ''test'', ''item.name is not what expected''); assert.equal(data.age, 0, ''item.age is not what expected''); assert.deepEqual(data.favoriteFoods, [''none''], ''item.favoriteFoods is not what expected''); assert.equal(data.__v, 0, ''The item should be not previously edited''); }, xhr => { throw new Error(xhr.responseText); })' + +``` + +
+ +## Challenge Seed +
+ +
+ +## Solution +
+ +```js +// solution required +``` +
diff --git a/curriculum/challenges/portuguese/05-apis-and-microservices/mongodb-and-mongoose/use-model.findone-to-return-a-single-matching-document-from-your-database.portuguese.md b/curriculum/challenges/portuguese/05-apis-and-microservices/mongodb-and-mongoose/use-model.findone-to-return-a-single-matching-document-from-your-database.portuguese.md new file mode 100644 index 0000000000..57dccd5bbb --- /dev/null +++ b/curriculum/challenges/portuguese/05-apis-and-microservices/mongodb-and-mongoose/use-model.findone-to-return-a-single-matching-document-from-your-database.portuguese.md @@ -0,0 +1,41 @@ +--- +id: 587d7fb7367417b2b2512c0c +title: Use model.findOne() to Return a Single Matching Document from Your Database +localeTitle: Use model.findOne () para retornar um único documento correspondente do seu banco de dados +challengeType: 2 +--- + +## Description +
+Model.findOne () se comporta como .find (), mas retorna apenas um documento (não uma matriz), mesmo se houver vários itens. É especialmente útil ao pesquisar por propriedades que você declarou como exclusivas. Encontre apenas uma pessoa que tenha uma certa comida em seus favoritos, usando Model.findOne () -> Person. Use o argumento de função food como chave de busca. +
+ +## Instructions +
+ +
+ +## Tests +
+ +```yml +tests: + - text: Encontrar um item deve ser bem sucedido + testString: 'getUserInput => $.post(getUserInput(''url'') + ''/_api/find-one-by-food'', {name: ''Gary'', age: 46, favoriteFoods: [''chicken salad'']}).then(data => { assert.equal(data.name, ''Gary'', ''item.name is not what expected''); assert.deepEqual(data.favoriteFoods, [''chicken salad''], ''item.favoriteFoods is not what expected''); assert.equal(data.__v, 0, ''The item should be not previously edited''); }, xhr => { throw new Error(xhr.responseText); })' + +``` + +
+ +## Challenge Seed +
+ +
+ +## Solution +
+ +```js +// solution required +``` +