Criar um novo usuário no moodle com a permissão core_user_create_user.

Para isso acesse o Administração de site -> servidor -> web services->`Serviços externos`.

Adicionar uma nova permissão, cadastre seguindo este template:

Depois deste passo basta salvar esta nova persmissão.

Criar um token de acesso que possui esta permissão.

Para isso navegue para: Servidor ->`Web Services` -> `Gerenciar tokens`

Criar um token com esta permissão que foi criada...

Pronto, agora basta configurar o postman, para testes e depois integrar à sua API.

Uma coisa a se notar é que o moodle possui política de senha dessa forma é necessário colocar uma senha que atenda a esta política.

Possuo um Feign Client para fazer requisições em serviços de terceiros.

Desejo exibir a mensagem de erro corretamente de acordo com os erros apresentados.

Para isso basta capturar os erros de acordo com a exceção lançada pelo cliente Feign.

Possuo o seguinte método, que faz a busca de um usuário em uma api externa:

public EntityModel<UserDTO> findUserByCpf(@PathVariable(value = "cpf")String cpf)  {
    UserDTO user = null;
    user = demoClient.getUser(cpf);

    return EntityModel.of(user);
}

O método acima está simplificado para um melhor entendimento, desejo complementar a implementação deste método para tratar os erros adequadamente, para poder "setar" a mensagem de erro corretamente de acordo com o erro recebido pelo Feign client.

Basta adicionar um bloco try ... catch e tratar os erros de acordo com as exceções enviadas pelo Feign Client.

public EntityModel<UserDTO> findUserByCpf(@PathVariable(value = "cpf")String cpf)  {
    UserDTO user = null;
    try {
        user = demoClient.getUser(cpf);
    } catch (Exception ex) {
        if (ex instanceof FeignException.BadRequest) {
            String bodyErrorMessage = ((FeignException.BadRequest) ex).contentUTF8();
            DemoClientErrorHandler democlienterror = objectMapperDefaultErrorConfig().readValue(bodyErrorMessage, DemoClientErrorHandler.class);
            }
    }
    //tratar os outros tipos de erros
    return EntityModel.of(user);
}

Basicamente a minha entidade DemoClientErrorHandler é um mapeamento em classes Java (POJO) de um "erro" da API externa que estou utilizando.

Para este exemplo eu usei apenas o BadRequest mas podem ser utilizados quantos forem necessários, basta seguir o que a documentação direciona.

Para implementar este código utilizei esta referência.

Uma maneira de solucionar o problema é renomear o arquivo a partir do ponto que já possui os dados do req.file, após ter passado no middleware do multer.

Toda essa configuração abaixo é feita apenas no backend (servidor) [nodejs].

A solução, de maneira resumida funciona assim:

1. recebe um arquivo (multipart/form-data) no primeiro middleware (ali onde tem o upload.single)
2. a partir do segundo middleware já possuo os dados para renomear o arquivo (os dados estão no objeto req.file) são os padrões do multer
3. uso a lib nativa do nodejs fs para renomear o arquivo, através da função fs.renameSync
4. Renomeia o arquivo através do valor da variável req.file.originalname.
5. no servidor o arquivo estará no caminho relativo uploads/

Por exemplo: Um arquivo que tenha sido feito o upload vai possuir o nome no padrão do multer (para este passo eu não configurei o multer para nomear os arquivos. Dessa forma o arquivo que é enviado ao meu servidor (ao terminar o primeiro middleware (que é o do próprio multer), vai possuir o nome no seguinte padrão (2a39086031204b49df1b80322e9cd5ff), após isso, no segundo middleware (fileNameUploadRename) posso renomear o arquivo.

Veja um exemplo de implementação de um middleware que possui esta lógica:

const fs = require('fs');

const multer = require('multer');

const upload = multer({
    dest: 'uploads/'
});
router.post('/adicionarCurso', upload.single('certificado'), (req, res) => {
    try {
        fs.access(`${req.file.destination}${req.file.originalname}`, fs.constants.COPYFILE_EXCL, (err) => {
            if (err && err.errno === -2) {
                fs.renameSync(req.file.path, `${req.file.destination}/${req.file.originalname}`);
                res.status(200).json({ msg: 'Operação realizada com sucesso' });
                return;
            }
            res.status(409).json({ msg: 'O arquivo já existe' });
            fs.unlinkSync(req.file.path);
        })
    } catch (err) {
        res.status(500).json({
            err: "Houve um erro ao atualizar o certificado, tente novamente"
        })
    }
});

Para mais informações consulte a documentação do fs e valores das constantes do fs

Repare que no exemplo acima eu faço uso de algumas funções específicas da função `fs`. Por exemplo uso a constante `COPYFILE_EXCL` que fará operação de cópia falhar se o arquivo de destino já existir. Ou seja, não desejo sobre-escrever o arquivo. (O que vale é o primeiro a ser enviado), então eu recomendo que se deseja outro comportamento escolha a constante adequada para a sua situação.

Referências:

File system | Node.js v23.0.0 Documentation

Node.js v23.0.0 Documentation

File system | Node.js v23.0.0 Documentation

Node.js v23.0.0 Documentation

Possuo uma tabela com a seguinte configuração:

Desejo filtrar minha coluna nome que é do tipo string, só com os dados que comecem com números, como proceder?

Uma maneira de resolver o problema é utilizando uma composição de funções, utilizando a função substring com isnumeric.

O algoritmo para esta solução pode ser descrito da seguinte forma:

Exiba todas as ocorrências que possui a coluna nome que a primeira letra que seja um valor numérico.

Dessa forma em SQL temos:

A função substring vai "recortar" a string nome, e vai retornar o caractere de índice zero da coluna nome. Verificar se este caractere é do tipo numérico através da função isnumeric

Explicando o funcionamento da função isnumeric:

ISNUMERIC retorna 1 quando a expressão de entrada é avaliada como um tipo de dados numérico válido; caso contrário, retorna 0 (zero).

Compondo as funções, temos a seguinte consulta:

SELECT * FROM cursos WHERE ISNUMERIC(SUBSTRING(nome,1,1)) = 1;

Para resultados mais robustos recomendo utilizar uma função trim para remover qualquer espaço em branco incluído acidentalmente na string nome.

SELECT * FROM cursos WHERE ISNUMERIC(SUBSTRING(TRIM(nome),1,1)) = 1;

Referências:

SUBSTRING (Transact-SQL) - SQL Server

Referência de Transact-SQL para a função SUBSTRING. Essa função retorna uma parte de uma expressão de caractere, binário, texto ou imagem especificada.

Microsoft LearnMikeRayMSFT

ISNUMERIC (Transact-SQL) - SQL Server

ISNUMERIC determina se uma expressão é um tipo numérico válido.

Microsoft Learnmarkingmyname

TRIM (Transact-SQL) - SQL Server

Remove o caractere de espaço ou outros caracteres especificados do início e do final de uma cadeia de caracteres.

Microsoft LearnWilliamDAssafMSFT

Para criar este projeto assumimos que:

• O certificado é autoassinado
• É uma aplicação que vai funcionar para testar algumas funcionalidades que devem ser servidas via https
• o certificado é configurado diretamente na aplicação nodejs-express.

Vamos então ao código:

Criamos um novo projeto chamado expressapphttps após criar o diretório podemos criar um novo projeto node.

Supondo que está dentro do diretório expressapphttps rodar o comando npm init

Após responder as perguntas terá um projeto no estado inicial, editar o arquivo:

***package.json*** neste arquivo editar a seção scripts adicionar duas linhas, as linhas que contém "start" e "dev".

{
  "name": "expressapphttps",
  "version": "1.0.0",
  "description": "express",
  "main": "app.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    "start": "node app.js",
    "dev": "node --watch app.js"
  },
  "author": "danizavtz",
  "license": "Apache-2.0",
  "dependencies": {
    "express": "^4.19.2"
  }
}

Após editar este arquivo, adicionar um novo arquivo app.js, o conteúdo desse arquivo deve ser:

***app.js***

const express = require('express')
const https = require('https')
const fs = require('fs')
const path = require('path')
const app = express();

app.use('/', (req, res) => {
    rres.send('hello I am SSL Server !')
});

const options = {
    key: '',
    cert: ''
}
const port = process.env.PORT || 8080;
const sslServer = https.createServer(options, app);
sslServer.listen(port, () => {
    console.log(`Secure server is listening on port ${port}`)
});

Primeiramente criamos um certificado válido. Para isto segui o tutorial desta postagem de blog.

Os certificados gerados devem ser colocados no diretório cert .

Após os certificados estarem nos locais devidos, vamos apenas editar para adicionar o caminho relativo para os certificados:

const express = require('express')
const https = require('https')
const fs = require('fs')
const path = require('path')
const app = express();

app.use('/', (req, res) => {
    res.send('hello I am SSL Server !')
});

const options = {
    key: fs.readFileSync(path.join(__dirname, './cert/key.pem')),
    cert: fs.readFileSync(path.join(__dirname, './cert/cert.pem'))
}
const port = process.env.PORT || 8080;
const sslServer = https.createServer(options, app);
sslServer.listen(port, () => {
    console.log(`Secure server is listening on port ${port}`)
});

Pronto, agora após iniciar a aplicação será possível utilizar est aplicação através do protocolo https.

Uma maneira de resolver o problema é utilizar o shell para "montar" a data e criar a tabela com o resultado de um alias para data.

Segue um exemplo, de como será o resultado do nome da tabela:

echo "tbl_xpto_$(printf '%(%d_%m_%Y)T' -1)"

A saída para este comando acima é o seguinte:

tbl_xpto_07_03_2024

Verifique que os valores mudam de acordo com a data atual, então dependendo do dia que executar o comando, pode receber outro resultado, pois no comando acima, estamos formatando uma saída de data, no formato (dd_MM_YYYY)

Pronto, agora que já sabe como vai ser o nome da tabela, basta utilizar esta mesma lógica para executar este comando utilizando o psql.

Segue um exemplo:

Uma maneira de resolver o problema é utilizar o shell para "montar" a data e criar a tabela com o resultado de um alias.

Segue um exemplo, de como será o resultado do nome da tabela:

echo "tbl_xpto_$(printf '%(%d_%m_%Y)T' -1)"

Uma maneira de resolver é utilizando uma stored procedure, basta criar uma procedure e depois executar esta stored procedure.

CREATE OR REPLACE PROCEDURE CRIAR_TABELA_DATA_HOJE() LANGUAGE plpgsql AS
$func$
BEGIN
    execute format('create table tbl_xpto%s as table tbl_xpto', to_char(now(), 'DD_MM_YYYY'));
END;
$func$;

Um caso de uso real

Vamos criar uma tabela usuario e inserir 4 usuários.

CREATE TABLE IF NOT EXISTS usuario (
    id UUID DEFAULT gen_random_uuid(),
    nome VARCHAR(32)
);

INSERT INTO usuario (nome) VALUES ('a');
INSERT INTO usuario (nome) VALUES ('b');
INSERT INTO usuario (nome) VALUES ('c');
INSERT INTO usuario (nome) VALUES ('d');

Agora queremos criar a nossa stored_procedure que vai criar uma nova tabela usuario07_03_2024. A stored_procedure deve ser da seguinte forma:

CREATE OR REPLACE PROCEDURE CRIAR_TABELA_DATA_HOJE() LANGUAGE plpgsql AS
$func$
BEGIN
    execute format('create table usuario%s as table usuario', to_char(now(), 'DD_MM_YYYY'));
END;
$func$;

Repare que no comando acima, estamos formatando uma data para o formato de string desejado, e o operador possui o mesmo funcionando do formatador de saída no C. Então o resultado será uma data formatada no padrão (DD_MM_YYYY), separada por underline (_)

Depois para executar a stored_procedure basta executar:

CALL CRIAR_TABELA_DATA_HOJE()

Ao executar o comando deve existir uma nova tabela em seu esquema do banco de dados.

Para verificar, basta rodar o comando \dt

               List of relations
 Schema |       Name        | Type  |  Owner   
--------+-------------------+-------+----------
 public | usuario           | table | ***
 public | usuario07_03_2024 | table | ***
(2 rows)

=# select * from usuario08_03_2024 ;
                  id                  | nome 
--------------------------------------+------
 2d668121-39b4-4397-ada0-3760f1adccc3 | a
 51f3ec21-61bc-4b42-b7d2-99368b8dd91e | b
 bbbd5aab-db12-4214-a7cc-84149812e94a | c
 6e441abf-dc2e-48c1-a3af-d9cd3a76172f | d
(4 rows)

Uma solução utilizando o shell

Uma segunda maneira de resolver o problema é utilizar o shell para "montar" a data e criar a tabela com o resultado de um alias.

Segue um exemplo, de como será o resultado do nome da tabela:

echo "tbl_xpto_$(printf '%(%d_%m_%Y)T' -1)"

A tabela completa dos formatadores pode ser vista na documentação do comando date

Pronto, agora que já sabe como vai ser o nome da tabela, basta utilizar esta mesma lógica para executar este comando utilizando o psql.

Segue um exemplo:

psql -U <usuario> <nome-db> -c "CREATE TABLE tbl_xpto_$(printf '%(%d_%m_%Y)T' -1) AS TABLE tbl_01"

Repare que no comando acima, estamos passando o parâmetro -c e no argumento deste parâmetro passamos o comando DDL que cria a cópia da tabela.

Substitua o valor <nome-db> pelo nome do seu banco de dados. Assim como valor do <usuario> pelo nome do seu usuário correspondente à sua configuração do banco de dados.

Vale ressaltar também que as regras de formação de nome das tabelas do postgres não é possível ter nomes com - (dash), mas se gostaria de utilizar o dash no nome da tabela, pode utilizar a forma de nomes de tabelas literais (onde o nome da tabela deve ser envolvido em aspas duplas). Para saber as regras leia a documentação da sintaxe das palavras chaves.

Após a execução com sucesso, deve ser solicitado a senha do banco de dados.

Ao final, se tudo ocorrer com sucesso, deve ser exibido a quantidade de linhas contida na tabela.

Como referências para esta resposta utilizei esta publicação.

Além da documentação do Postgres

Para este tutorial, estou supondo que já possui um projeto escrito em JavaScript, e deseja adicionar o ESlint afim de fazer análise estática do código procurar por errors de sintaxe, erros de lógica a nível de código e verificação de estilo de código.

Então caso já possua o seu projeto em JavaScript, pode fazer essa configuração em seu projeto diretamente seguindo as instruções contidas aqui.

Caso não possua, um projeto você pode utilizar este projeto de exemplo que criei, e continuar seguindo as intruções para fazer a sua configuração. Este projeto é uma prova de conceito apenas para praticar a configuração do ESlint em um projeto que não possui o ESlint configurado. Neste projeto é que vamos configurar o ESlint do zero.

Para utilizar a minha prova de conceito, apenas vá ao repositório e siga as instruções para instalação.

• Clone o projeto
• Instale as dependências

Pronto, agora você já possui todos os requisitos para fazer a configuração do ESlint.

Neste tutorial vamos seguir o que orienta a documentação sobre como configurar um projeto, para isso, supondo que está na raiz do projeto que acabou de baixar, basta executar o comando:

  npm init @eslint/config

Após executar este comando, essa será a saída esperada caso dê tudo certo:

Need to install the following packages:
eslint/create-config@0.4.6
Ok to proceed? (y) y

Respondi que sim, e desta forma houve um passo-a-passo no formato de wizard de shell para fazer a configuração do ESlint em meu projeto.

Para isso vá respondendo perguntas de acordo com o estilo e com o problema que o seu aplicativo visa resolver.

Primeira pergunta, como gostaria de utilizar o ESlint?

? How would you like to use ESLint?

Alternativas:

• Para verificar apenas a sintaxe
• Para verificar a sintaxe e encontrar problemas
• Para verificar a sintaxe, encontrar problemas e aplicar estilo de código

Na próxima pergunta temos, que tipo de módulos seu projeto usa?

What type of modules does your project use?

Alternativas:

• JavaScript modules (import/export)
• CommonJS (require/exports)
• Nenhum desses

Próxima, Qual framework seu projeto usa?

Which framework does your project use?

Alternativas:

• React
• Vuejs
• Nenhum

Neste caso selecionamos nenhum, já que o nosso projeto é de backend, e não vamos ter nenhum tipo de framework relacionado à backend.

A seguinte, seu projeto usa TypeScript?

 Does your project use TypeScript?

Aqui é simples, sim ou não.

Logo em seguida, tem a próxima, onde seu projeto roda?

Where does your code run?

Alternativas:

• Navegador
• Node

Essa próxima pode ser a última pergunta, como você gostaria de definir um estilo para o seu projeto?

 How would you like to define a style for your project?

Alternativas, aqui temos uma lista de alternativas, que eu sugiro que dê uma pesquisada (se ainda não conhece algum), minha escolha pessoal é o standard ("padrão"), mas veja o que melhor se adequa ao seu projeto. Nas alternativas existem links, então você pode acessar diretamente e descobrir a melhor escolha.

Alternativas:

• Airbnb: https://github.com/airbnb/javascript
• Standard: https://github.com/standard/standard
• Google: https://github.com/google/eslint-config-google
• XO: https://github.com/xojs/eslint-config-xo

mais uma, em que formato você deseja que seu arquivo de configuração esteja?

What format do you want your config file to be in?

Neste caso as alternativas são auto-explicativas.

a próxima, ele fez uma verificação pelas minhas escolhas, e verificou que é necessário mais algumas depedências, e perguntou se eu gostaria de instalar. Gostaria de instalá-los agora?

Checking peerDependencies of eslint-config-standard@latest
Local ESLint installation not found.
The config that you've selected requires the following dependencies:
eslint-config-standard@latest eslint@^8.0.1 eslint-plugin-import@^2.25.2 eslint-plugin-n@^15.0.0 || ^16.0.0  eslint-plugin-promise@^6.0.0

Aqui fica a seu critério, eu respondi que não, pois não quero adicionar muitas dependências no projeto, aqui eu prefiro ser conservador e manter o mínimo possível de dependências no meu projeto, e ir instalando conforme necessidade. Mas fique à vontade para instalar as dependências.

Por último, Qual gerenciador de pacotes você usa?

Pronto, agora você já possui o ESlint instalado, e pode executar o lint em qualquer arquivo.

Basta rodar o comando:

npx eslint <seuarquivo>.js

Neste caso o nosso projeto possui apenas um arquivo .js (que é o arquivo app.js), dessa forma vou executar o ESlint apenas nele.

npx eslint app.js

Essa deve ser a saída esperada para o comando acima (supondo que não fez nenhuma mudança nos arquivos fonte da aplicação).

1:35  error  Extra semicolon                                semi
3:22  error  Extra semicolon                                semi
5:1   error  Expected indentation of 2 spaces but found 4   indent
5:50  error  Extra semicolon                                semi
6:3   error  Extra semicolon                                semi
7:38  error  Extra semicolon                                semi
8:17  error  Extra semicolon                                semi
9:63  error  Extra semicolon                                semi
9:64  error  Newline required at end of file but not found  eol-last

Aqui uma exibição simples, uma linha com cada erro que ocorre no arquivo, agora é só corrigir os problemas detectados pelo lint.

Essas verificações no código seguem as regras que estão no arquivo .eslintrc que foi adicionado ao projeto, após a execução do wizard. É nesse arquivo que você pode personalizar as regras que devem ser verificadas ao rodar o comando npx eslint ...

Você pode adicionar novas regras no nó rules, do arquivo .eslintrc , as regras que você pode adicionar podem ser procuradas na documentação.

Para esta aplicação e as configurações atuais, eu ainda desejo adicionar mais algumas regras, segue o conteúdo do meu arquivo (aqui é javascript, então adapte a solução para o seu tipo de arquivo [você escolheu o formato do arquivo durante o wizard]).

module.exports = {
  env: {
    browser: true,
    commonjs: true,
    es2021: true
  },
  extends: 'standard',
  overrides: [
    {
      env: {
        node: true
      },
      files: [
        '.eslintrc.{js,cjs}'
      ],
      parserOptions: {
        sourceType: 'script'
      }
    }
  ],
  parserOptions: {
    ecmaVersion: 'latest'
  },
  rules: {
    'no-console': 2,
        'no-useless-catch': 'off',
        'indent': [
            'error',
            4
        ],
        'linebreak-style': [
            'error',
            ((process.platform === 'win32' || process.platform === 'win64') ? 'windows' : 'unix')
        ],
        'quotes': [
            'warn',
            'single',
        ],
        'semi': [
            'error',
            'always'
        ],
        'eol-last': [
            'error',
            'always'
        ]
  }
}

Agora, após selecionar suas regras de lint para o seu projeto, você pode criar um novo comando em seu módulo, para se encarregar desta tarefa de verificar o lint. A vantagem de ter o script é pra facilitar as tarefas de automação de esteira de CI/CD além de manter mais organizado a execução das tarefas através do uso de uma unica ferramenta para centralizar o uso, nesse caso o npm. Então edite o seu arquivo para  package.json. Fazer essa configuração é melhor para um caso de uso de projetos de mundo real.

Em geral, os meus arquivos de implementação do server (aplicativo express/node) ficam organizados no server então eu crio o meu padrão de verificação de arquivos em pastas da seguinte forma:

***package.json***

{
  "name": "eslintconfiguration",
  "version": "1.0.0",
  "description": "",
  "main": "app.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    "start": "node app.js",
    "dev": "node --watch app.js",
    "lint": "npx eslint server/**/*.js server/*.js lib/*.js app.js",
  },
  "repository": {
    "type": "git",
    "url": "git+ssh://git@github.com/danizavtz/eslintconfiguration.git"
  },
  "keywords": [
    "nodejs"
  ],
  "author": "danizavtz",
  "license": "ISC",
  "bugs": {
    "url": "https://github.com/danizavtz/eslintconfiguration/issues"
  },
  "homepage": "https://github.com/danizavtz/eslintconfiguration#readme",
  "dependencies": {
    "express": "^4.18.2"
  },
  "devDependencies": {
    "eslint": "^8.56.0"
  }
}

Em destaque a linha que adicionei na seção scripts do meu arquivo package.json.

"lint": "npx eslint server/**/*.js server/*.js lib/*.js app.js",

Nesse caso todas as vezes que eu executar o comando npm run lint serão verificados com o ESlint:

• todos arquivos com extensão .js que estão nos subdiretórios que estão na pasta server .
• todos os arquivos com extensão .js que estão no diretório server.
• todos os arquivos com extensão .js que estão no diretório lib.
• o arquivo app.js

A vantagem de fazer uma configuração assim é que automaticamente, se forem adicionados novos arquivos em qualquer um desses diretórios, eles serão verificados pelas regras descritas acima. Essa é apenas uma ideia de como organizar então você pode adaptar para o seu projeto.

Agora é só corrigir os problemas de lint ;-)

Fiz um projeto no Flask e está no server de teste na porta 5000, alguém como faço para liberar o app para rede local?

Uma maneira de resolver o problema, é setando a variável host da sua aplicação Flask para o valor 0.0.0.0.

Segue um exemplo da configuração que deve ser feita:

hello.py

from flask import Flask

app = Flask(__name__)

@app.route("/")
def hello_world():
    return "<p>Hello, World!</p>"

if __name__ == "__main__":
    app.run(host='0.0.0.0')

Depois para executar a aplicação, devemos executar com o seguinte comando:

python hello.py

Repare nas mensagens que são exibidas no shell

* Serving Flask app 'hello'
* Debug mode: off
WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
* Running on all addresses (0.0.0.0)
* Running on http://127.0.0.1:5000
* Running on http://192.168.157.x:5000

Desta forma será feito o bind da sua aplicação com todos os endereços ip atuais que estão ligados ao seu host e na porta especificada.

Sua aplicação agora está acessível via a rede local.

Repare que neste exemplo coloquei um x no último endereço que está no log. Isso não é um endereço IP válido. Deixei assim proposital para caso acesse este endereço ocorrer um erro. O endereço que você deve acessar é o que está sendo exibido no log da aplicação, no shell do seu interpretador Python.

Você pode acessar esta aplicação completa no github.

Configuração via linha de comando

Também é possível configurar o host via linha de comando, neste caso basta utilizar o comando:

flask --app hello run --host 0.0.0.0

Repare que aqui a ordem dos argumentos é importante e o --host deve ser após o comando run. Neste caso estou supondo que o script escrito em Python se chamada hello.py.

Para mais informações consulte a documentação.

Estou digitando na linha de comando npm run dev e está retornando esse erro:

npm ERR! Missing script: "dev"
npm ERR!
npm ERR! To see a list of scripts, run:
npm ERR!   npm run

Isso ocorre porque não foi possível localizar o comando dev em seu arquivo package.json

O seu package.json é considerado um arquivo manifest do seu projeto em javascript (ou nodejs). Se você já utilizou algum javascript minimamente moderno de alguma maneira você já interagiu com o npm.

Quando criamos um package.json ele possui uma seção scripts, que na verdade é apenas um nó do json em que possui alias para outros comandos. Nesta seção do arquivo é que podemos modificar para adicionar o script que está faltando.

Se você nunca criou uma aplicação em javascript do zero. Possivelmente não precisou criar um package.json. A maneira correta de fazer isso é via o comando npm init

ao executar este comando, vamos responder algumas perguntas de alguns campos obrigatórios, estas perguntas segue o modelo wizard (que é feito no próprio shell).

Ao final da execução do comando npm init o package.json gerado fica assim:

{
  "name": "newproj",
  "version": "1.0.0",
  "description": "test",
  "main": "app.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [
    "nodejs"
  ],
  "author": "danizavtz",
  "license": "ISC"
}

O conteúdo do arquivo vai variar, pois depende das perguntas respondidas previamente. Veja que neste arquivo gerado, existe a seção scripts é lá que devemos adicionar scripts ao projeto, temos "por padrão" um comando test (e esse é o único script em nosso package.json gerado via linha de comando), vamos executar ele para ver o que acontece.

npm run test

> newproj@1.0.0 test
> echo "Error: no test specified" && exit 1

Error: no test specified

Ele está fazendo explicitamente o que está determinado lá no nó test da nossa seção scripts. Que é,

• executar o comando echo
• sair com código 1

O comando echo vai escrever argumentos na linha de comando. O retorno zero indica ao SO que o programa foi bem sucedido. Cada outro número retornado indica o código de uma condição de erro. Como explicitamente estamos retornando 1 isso será interpretado como uma condição de erro.

Um script npm é uma maneira de agrupar tarefas comuns. Podem ser comandos de terminal ou uma sequencia de tarefas que ajudam a automatizar tarefas repetitivas.

Em geral as tarefas mais comuns de serem executadas são:

• levantar um servidor e deixar ele no modo listening
• rodar uma especie de live-reloading para ajudar no desenvolvimento
• executar linter
• executar testes
• gerar uma build
• minificar código fonte
• ofuscar código fonte

Estes scripts declarados no package.json podem ser usados para auxiliar no momento de deploy e na escrita da pipeline de integração contínua e entrega contínua do projeto (CI/CD).

Então quando criamos um projeto utilizando nodejs do zero, o único script que é incluído no package.json é o script test, que apenas exibe a seguinte mensagem no terminal: Error: no test specified.

Então, se o package.json não possui o script dev então basta criar este script e depois invocar o mesmo.

Como criar um novo script

Afim de criar um novo script no package.json abra o seu editor de texto e apenas adicione a seguinte linha.

"dev": "echo dev"

Segue o package.json completo.

{
  "name": "newproj",
  "version": "1.0.0",
  "description": "test",
  "main": "app.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    "dev": "echo dev"

  },
  "keywords": [
    "nodejs"
  ],
  "author": "danizavtz",
  "license": "ISC"
}

Agora ao executar o comando npm run dev agora será exibida a mensagem dev no terminal.

> newproj@1.0.0 dev
> echo dev

dev

Pronto, agora você já possui um script dev em seu package.json

Realmente, em alguns frameworks, como angular/react/vuejs, como eles utilizam ferramentas de linha de comando para criar um novo projeto, eles já facilitam a vida do desenvolvedor e criam alguns scripts pensando em experiência do desenvolvimento. Então é comum vermos alguns scripts a mais, em nosso package.json.

Em angular por exemplo, temos os seguintes scripts:

{
//...
"scripts": {
    "ng": "ng",
    "start": "ng serve -c -o",
    "build": "ng build",
    "watch": "ng build --watch --configuration development",
    "test": "ng test",
    "e2e": "ng e2e",
    "staging": "ng build --configuration=staging",
    "qa": "ng build --configuration=qa --base-href=/qa/",
    "cypress:open": "cypress open",
    "cypress:run": "cypress run",
    "lint": "ng lint"
  },
//...
}

Em vuejs:

{
//...
"scripts": {
     "serve": "vue-cli-service serve",
     "build": "vue-cli-service build",
     "test:unit": "vue-cli-service test:unit",
     "test:e2e": "vue-cli-service test:e2e",
     "lint": "vue-cli-service lint"
},
//...
}

Então fica à critério do desenvolvedor, criar o script.

Em meus projetos pessoais de backend, eu crio os scripts, e em geral é pra executar os testes, exibir a cobertura dos testes, e executar a aplicação do backend em uma espécie de live-reload (quando existem mudanças), que nada mais é do que executar o backend via o node, passando como argumento o --watch.

Então em meu projeto, personalizo o script de dev, para o seguinte:

"dev": "node --watch bin/www",

Para utilizar o node com o argumento --watch é necessário ter instalado a versão do nodejs > 18.0.0.

Um exemplo de um package.json "do mundo real" pode ser visto aqui.

Possuo um endpoint que já funciona e retorna JSON. É um endpoint que retorna uma lista de itens, e desejo que quando o usuário chamar o endpoint o navegador execute a ação padrão de fazer o download, e consequentemente salve o arquivo no diretório configurado como padrão para baixar.

Esse é o fluxo que desejo implementar, desta forma, vamos mostrar através de um exemplo concreto como programar esta funcionalidade.

Do ponto de vista de implementação tudo isso pode ser conseguido através de mudanças no backend.

Vamos então para a estrutura de dados:

[{
    "id" : "f7379ae8-8f9b-4cd5-8221-51efe19e721b",
    "apelido" : "josé",
    "nome" : "José Roberto",
    "nascimento" : "2000-10-01",
    "stack" : ["C#", "Node", "Oracle"]
},
{
    "id" : "5ce4668c-4710-4cfb-ae5f-38988d6d49cb",
    "apelido" : "ana",
    "nome" : "Ana Barbosa",
    "nascimento" : "1985-09-23",
    "stack" : ["Node", "Postgres"]
}]

Em nosso serviço, temos um array composto por umusuario que foi definida na rinha de backend.

Temos agora uma abstração de um usuário. Dessa forma vamos implementar um endpoint para recuperar estas informações. Segue a definição do serviço, que é uma aplicação em nodejs que utiliza o express (estou supondo que já possui uma configuração inicial de um projeto express, esta tarefa é trivial mas se quer um exemplo que mostra como fazer a configuração inicial, pode ler esta postagem):

const express = require('express')
const app = express()
app.use(express.json())

app.get('/usuarios', (req, res) => {
    const usuarios = [{
        "id" : "f7379ae8-8f9b-4cd5-8221-51efe19e721b",
        "apelido" : "josé",
        "nome" : "José Roberto",
        "nascimento" : "2000-10-01",
        "stack" : ["C#", "Node", "Oracle"]
    },
    {
        "id" : "5ce4668c-4710-4cfb-ae5f-38988d6d49cb",
        "apelido" : "ana",
        "nome" : "Ana Barbosa",
        "nascimento" : "1985-09-23",
        "stack" : ["Node", "Postgres"]
    }];
    res.status(200).json(usuarios)
})

Já temos um serviço com uma rota que retorna todos os usuários.

Criando uma rota que retorna um arquivo para download JSON

Já temos a rota que retorna os dados que desejamos que é a rota /usuarios. Agora é só fazer o envio destes mesmos dados no formato json.

Para isso vamos apenas adicionar o header Content-Type com os valores application/json e adicionar o header 'Content-Disposition com o valor 'attachment; filename=test.json'

Esse header é o que vai realmente fazer a mágica acontecer.

Dessa forma criarei uma nova rota /usuarios/download que contém essa implementação:

app.get('/usuarios/download', (req, res) => {
        const usuarios = [{
            "id" : "f7379ae8-8f9b-4cd5-8221-51efe19e721b",
            "apelido" : "josé",
            "nome" : "José Roberto",
            "nascimento" : "2000-10-01",
            "stack" : ["C#", "Node", "Oracle"]
        },
        {
            "id" : "5ce4668c-4710-4cfb-ae5f-38988d6d49cb",
            "apelido" : "ana",
            "nome" : "Ana Barbosa",
            "nascimento" : "1985-09-23",
            "stack" : ["Node", "Postgres"]
        }];
        res.setHeader('Content-Disposition', 'attachment; filename=test.json');
        res.status(200).send(usuarios).end()
    })

Repare que aqui o nome do arquivo é test.json (você pode substituir pelo nome que desejar, desde que sigam as restrições definidas na RFC 6266, que versa sobre o campo header Content-Disposition).

Outra maneira de implementar esta mesma funcionalidade é usar a função helper implementada pelo express download. Segue um exemplo de como podemos utilizar a função download.

const fs = require('fs');
//...
app.get('/usuarios/download', (req, res) => {
    const usuarios = [{
        "id" : "f7379ae8-8f9b-4cd5-8221-51efe19e721b",
        "apelido" : "josé",
        "nome" : "José Roberto",
        "nascimento" : "2000-10-01",
        "stack" : ["C#", "Node", "Oracle"]
    },
    {
        "id" : "5ce4668c-4710-4cfb-ae5f-38988d6d49cb",
        "apelido" : "ana",
        "nome" : "Ana Barbosa",
        "nascimento" : "1985-09-23",
        "stack" : ["Node", "Postgres"]
    }];
    fs.writeFileSync('data.json', usuarios);
    res.download('data.json', 'test.json');
});

Veja que nesse exemplo foi necessário utilizar a função fs que manipula arquivos. Dessa forma vamos escrever no sistema de arquivos um arquivo que possui o nome data.json e após escrever o conteúdo da variável usuario neste arquivo, fazemos o envio deste arquivo para o cliente, através da chamada da função download. A definição do serviço completo pode ser visto aqui.

Obrigado

Segundo a documentação:

SonarQube oferece suporte ao relatório de informações de cobertura de teste como parte da análise do seu projeto JS/TS.

No entanto, o SonarQube não gera o próprio relatório de cobertura. Em vez disso, você deve configurar uma ferramenta de terceiros para produzir o relatório como parte do seu processo de construção. Em seguida, você precisa configurar sua análise para informar ao SonarScanner onde o relatório está localizado, para que ele possa pegá-lo e enviá-lo ao SonarQube, onde será exibido no painel do seu projeto junto com as demais métricas de análise.

Para projetos JS/TS, o SonarQube oferece suporte direto a todas as ferramentas de cobertura que produzem relatórios no formato LCOV. Além disso, um formato de cobertura genérico também é suportado se você desejar usar uma ferramenta não suportada (embora você mesmo tenha que converter sua saída para o formato genérico).

Sabendo disso vamos integrar essa informação ao sonar afim de ser possível ler a informação da cobertura, essa informação é gerada através de outras ferramentas de terceiros que provêm os dados de cobertura no formato lcov, o sonar lê essas informações e disponibiliza como parte da análise.

Neste mesmo link, que compartilhei acima, existe um passo a passo para adicionar a informação da cobertura ao seu projeto. O objetivo desta publicação é adicionar a informação da cobertura ao sonar.

Requisitos:

• Ter um servidor sonar configurado
• Ter um cliente sonar configurado

Para isso vamos utilizar o projeto tokenAuthDatastore, que é um código fonte público que pode ser utilizado para testar essa configuração, após finalizar a leitura isso você pode integrar ao seu projeto. Esse projeto tokenAuthDatastore já possui bibliotecas para execução e geração de informação da cobertura. As ferramentas que utilizei neste projeto podem ser vistas nas configurações do package.json

chai, mocha, nyc, sinon, supertest

Vamos ao passo-a-passo:

clone o projeto:

  git clone git@github.com:danizavtz/tokenAuthDatastore.git

entre no diretório do projeto que foi clonado e instale as dependências:

cd tokenAuthDatastore
npm install

Agora basta executar os testes de cobertura neste projeto. Ao executar os testes de cobertura serão gerados meta-dados de cobertura do seu código fonte no diretório  .nyc_output é a partir dessas informações que será gerado o relatório de cobertura.

Sabendo disso, vamos executar a cobertura do código:

npm run coverage

Após executar a cobertura, gerar a informação de cobertura, com o seguinte comando:

npm run report-coverage

A partir dos meta-dados será gerado um novo arquivo na raiz do projeto, o arquivo coverage.lcov.

É esse arquivo que vai servir de insumo para gerar a informação de cobertura exibida no sonar. Agora basta executar a sua automação do sonar para ler este arquivo.

Agora vamos configurar este projeto no sonar, vamos fazer a configuração local, para isso siga os passos da interface gráfica do sonar:

Preencha as informações do projeto na página seguinte:

Repare que no campo main branch nameo nome da branch é o mesmo nome da branch que eu clonei o meu projeto, que neste caso é a branch master. (você pode verificar esta informação, executando o comando: git  branch no diretório raiz do projeto que deseja configurar).

Escolha o método de análise e clique em Generate. Para esse exemplo vou utilizar o método local, mas existem várias possibilidades de configuração, os relevantes são, Jenkins, Gitlab e Github além de outros.

Após clicar em generate, será encaminhado para a próxima tela onde será exibido o token. Agora basta apenas clicar em continue.

Como se trata de um projeto javascript, então eu seleciono a opção de acordo.

Após selecionar esta opção será apresentado o próximo menu com as instruções para executar o sonar no projeto. Clique no botão copiar.

O importante nesta tela é este comando para executar o sonar. Com este comando vá para o diretório raiz de onde o projeto foi clonado (o mesmo que possui o arquivo coverage.lcov, que geramos em um passo anterior). Este é o comando:

sonar-scanner.bat -D"sonar.projectKey=tokenAuthDatastore" -D"sonar.sources=." -D"sonar.host.url=http://localhost:9000" -D"sonar.token=sqp_ec913a0f15298a323d67862cfd3a5f3ecc49cdf8"

Após executar este comando será gerado um relatório do sonar. Ao gerar o relatório você verá que a cobertura está zerada.

Isso acontece pois é necessário passar mais alguns argumentos de linha de comando, para que seja possível localizar o arquivo *.lcove utilizar as informações contidas nele, seguindo a documentação compartilhada no inicio da publicação temos que passar este parâmetro com o seguinte argumento:

 sonar.javascript.lcov.reportPaths=coverage.lcov

Lembrando que o valor deste argumento, deve ser o nome do arquivo que possui a informação da cobertura, em nosso projeto o nome deste arquivo é coverage.lcov.

Então agora, basta executar o comando anterior novamente, com esse novo parâmetro com seu respectivo argumento. Segue o comando completo:

sonar-scanner.bat -D"sonar.projectKey=tokenAuthDatastore" -D"sonar.sources=." -D"sonar.host.url=http://localhost:9000" -D"sonar.token=sqp_ec913a0f15298a323d67862cfd3a5f3ecc49cdf8" -D"sonar.javascript.lcov.reportPaths=coverage.lcov"

Pronto, agora as informações de cobertura já estarão disponíveis, segue um exemplo de como deve ficar:

Agora só mais um ajuste, vemos que em nosso projeto, será executado o sonar em todas as pasta, mas na verdade eu não gostaria de analisar códigos presentes nos diretórios node_modules, assim como também no diretório tests.  Isso vai manter o foco da análise em meu código fonte desenvolvido.

Vamos então reduzir o escopo da análise, que pode ser conseguido através da exclusão de certos diretórios de serem analisados.

Vamos usar o parâmetro: sonar.exclusions .

O comando final fica assim:

sonar-scanner.bat -D"sonar.projectKey=tokenAuthDatastore" -D"sonar.sources=." -D"sonar.host.url=http://localhost:9000" -D"sonar.token=sqp_ec913a0f15298a323d67862cfd3a5f3ecc49cdf8" -D"sonar.javascript.lcov.reportPaths=coverage.lcov" -D"sonar.exclusions=test/**,node_modules/**"

Repare que no final eu utilizei a seguinte sintaxe: test/**. Isso está explicado na documentação, e é um padrão para ignorar subdiretórios e arquivos contidos nestes diretórios.

Agora ao executar o mesmo comando (adicionando as exclusões), temos a seguinte saída:

E isso encerra o nosso tutorial, vemos que o valor da cobertura está de acordo com o mesmo que é exibido no github. Por outra ferramenta a codecov. 🙌

Também é possível fazer estas mesmas configurações via interface gráfica sem a necessidade de utilizar a linha de comando,  basta seguir as instruções presentes na documentação, que já foi referenciada.

Agora que já configurou o sonar acrescentando a informação de cobertura em um projeto, será possível utilizar as mesmas ideias presentes aqui para outros projetos.

Nesta publicação vamos implementar uma integração com serviço AWS SES e vamos criar uma aplicação completa em que é possível enviar um e-mail.

Para esta implementação vamos utilizar as seguintes tecnologias, que utiliza o backend para renderizar o frontend e integrar o serviço da aws. É uma aplicação tradicional html renderizada no servidor (server side rendering). No modelo single page application.

• nodejs para backend e frontend (utilizando html puro)
• aws ses

O aws ses (é um serviço pago), essa implementação é uma prova de conceito de implementação de uma página de contato em que é enviado um e-mail para mim mesmo. Via o serviço da aws ses.

Você pode ver um exemplo do funcionamento da página aqui. Esta página não possui integração com  o backend, está disponível apenas para ser ter uma ídeia do funcionamento e como ficará o projeto depois de pronto (do ponto de vista de apresentação).

Implementando o frontend

A implementação do frontend possui apenas duas rotas uma para a GET vai renderizar o formulário de contato.

export default function layout({ contato }) {
  const { email, message, title, errors } = contato;
  return `
    <html lang="pt-br">
    <head>
      <title>Sendmail app</title>
        <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
        <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.2/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-T3c6CoIi6uLrA9TneNEoa7RxnatzjcDSCmG1MXxSR1GAsXEV/Dwwykc2MPK8M2HN" crossorigin="anonymous">
    </head>

    <body class="">
      <nav class="container-fluid navbar navbar-expand navbar-light bg-light">
        <ul class="navbar-nav ms-auto">
          <li class="nav-item"><a class="nav-link" href="/">Home</a></li>
        </ul>
      </nav>
      <main class="mt-4 container py-4 position-relative">
      <h2>Contato</h2>
      <form method="post" class="has-validation mt-3" action="/">
      <div class="mb-3">
          <label for="servicestatus" class="form-label"></label>
          <input type="hidden" class="form-control ${errors.service.length ? 'is-invalid': ''}" id="servicestatus" name="servicestatus" value="">
          <div class="invalid-feedback">
            ${errors.service.length > 0 ? errors.service[0]: ''}
          </div>
        </div>
        <div class="mb-3">
          <label for="email" class="form-label">E-mail</label>
          <input type="text" class="form-control ${errors.email.length ? 'is-invalid': ''}" id="email" name="email" value="${email}">
          <div class="invalid-feedback">
            ${errors.email.length > 0 ? errors.email[0]: ''}
          </div>
        </div>
        <div class="mb-3">
          <label for="title" class="form-label">Título</label>
          <input type="text" class="form-control ${errors.title.length ? 'is-invalid': ''}" id="title" name="title" value="${title}">
          <div class="invalid-feedback">
            ${errors.title.length > 0 ? errors.title[0]: ''}
          </div>
        </div>
        <div class="mb-3">
          <label for="message" class="form-label">Mensagem</label>
          <textarea class="form-control ${errors.message.length ? 'is-invalid': ''}" id="message" name="message">${message}</textarea>
          <div class="invalid-feedback">
            ${errors.message.length > 0 ? errors.message[0]: ''}
          </div>
        </div>
        <button id="btnenviar" type="submit" class="btn btn-primary">

        Enviar </button>
      </form>
      </main>
    </body>
    </html>
  `;
}

Outra a mesma rota para o POST que vai fazer a validação dos dados do formulário e caso esteja tudo certo fará o envio do e-mail. Caso seja feito o envio com sucesso, então sera exibida uma tela de sucesso ao enviar.

export default function sucesso() {
    return `
      <html lang="pt-br">
      <head>
        <title>Sendmail app</title>
          <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
          <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.2/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-T3c6CoIi6uLrA9TneNEoa7RxnatzjcDSCmG1MXxSR1GAsXEV/Dwwykc2MPK8M2HN" crossorigin="anonymous">
      </head>

      <body class="">
        <nav class="container-fluid navbar navbar-expand navbar-light bg-light">
          <ul class="navbar-nav ms-auto">
            <li class="nav-item"><a class="nav-link" href="/">Home</a></li>
          </ul>
        </nav>
        <main class="mt-4 container py-4 position-relative">
        <div class="row justify-content-md-center">
        <div class="col col-md-auto text-center">
          <div id="sucesso" class="d-flex justify-content-center h1"> Mensagem enviada com sucesso
          </div>
          <br>
          <a href="/" class="btn btn-primary justify-content-center" role="button">Voltar</a>
        </div>
      </div>
        </main>
      </body>
      </html>
    `;
  }

Agora para integrar os serviços vamos implementar a funcionalidade de envio de e-mai, como dito, o envio será feito via o serviço AWS  simple email service

Para isso vamos apenas adicionar a biblioteca do aws sdk, e criar uma instância do servico SES, ele vai ficar responsável pelo envio do e-mail.

Vamos instalar o sdk da aws, para isso utilize o npm install

npm install @aws-sdk/client-sesv2

Após fazer essa instalação, edite o arquivo server/index.js, adicionar o import e fazer as configurações básicas para o envio de um e-mail, nesta tarefa fomos guiados pela documentação da AWS do serviço sesv2.

O resultado final fica assim, aqui vou mostrar apenas a implementação do método sendMail:

async sendMail(req, res) {
    const contato = new Contato(req.body)
    if (contato.email.trim() === '') {
      contato.errors.email.push('E-mail não pode ser vazio')
    }
    if (contato.title.trim() === '') {
      contato.errors.title.push('Título não pode ser vazio')
    }
    if (contato.message.trim() === '') {
      contato.errors.message.push('Mensagem não pode ser vazio')
    }
    if (contato.errors && (contato.errors.email.length > 0 || contato.errors.message.length > 0 || contato.errors.title.length > 0)) {
      return res.send(layout({ contato: contato }))
    } //até aqui faz validação dos campos obrigatórios, renderiza o form com as mensagens de erro e os dados do formulário

    const input = { // SendEmailRequest
      FromEmailAddress: "contato@danizavtz.com.br",
      ReplyToAddresses: [
        "daniellucena@yahoo.com.br",
      ],
      Destination: { // Destination
          ToAddresses: [ // EmailAddressList
            "daniellucena@yahoo.com.br",
          ]
      },
      Content: { // EmailContent
        Simple: { // Message
          Subject: { // Content
            Data: req.body.title, // required
            Charset: "UTF-8",
          },
          Body: { // Body
            Text: {
              Data: `Mensagem de: ${req.body.email}, \nMensagem: ${req.body.message}`, // required
              Charset: "UTF-8",
            }
          }
        }
      }
    };
    const command = new SendEmailCommand(input);
    try {
        await client.send(command);
        res.send(sucesso())
    } catch (err) {
        console.log(err); //esta linha não é necessária, é utilizada apenas para debug
        contato.errors.service.push('Houve um erro durante o envio')
        return res.send(layout({ contato: contato }))
    }
  }

Repare que temos um input do tipo "hidden", ele serve para incluir a mensagem de erro no caso de haver um erro no envio, (quando esse erro vem do serviço aws-ses).

Veja a versão completa deste projeto.