---
# System prepended metadata

title: My personal cheatsheet

---

# My personal cheatsheet
Esse documento é básicamente uma "Colinha" sobre algumas coisas na programação

## Sending e-mails (Back-End)
Para o envio de emails utilizaremos um *SMTP* tal como o:

> [SendGrid](https://signup.sendgrid.com/?utm_source=google&utm_medium=cpc&utm_term=sendgrid&utm_campaign=Sitelink_SendGrid_G_S_LATAM_Brand_(English)&cq_plac=&cq_net=g&cq_pos=&cq_med=&cq_plt=gp)
> [NodeMailer](https://nodemailer.com/about/)

1. Criaremos uma conta no *SMTP* de sua escolha.
2. Criar e configurar um *Sender*
3. Instale o *NodeMailer* no seu projeto
4. Crie um *Transportador* e conecte com as chaves do seu *Sender*
```
const nodemailer = require("nodemailer");

const transporter = nodemailer.createTransport({
    host: "smtp.ethereal.email",
    port: 587,
    secure: false, // true for 465, false for other ports
    auth: {
      user: testAccount.user, // generated ethereal user
      pass: testAccount.pass, // generated ethereal password
    },
});

module.exports = tranporter;
```
5. Para enviar um email, utilize:

```
const tranporter = require('./transporter.js');

transporter.sendMail({
    from: `${email_name} <${email_from}>`,
    to: `${user.nome} <${user.email}>`,
    text: "Hello world?", // plain text body
    html: "<b>Hello world?</b>", // html body
  });
});
```
ou para uma lista de envio:
```
const tranporter = require('./transporter.js');

transporter.sendMail({
    from: `${email_name} <${email_from}>`,
    to: `bar@example.com, baz@example.com`,
    // varios emails separados por vigula
    
    text: "Hello world?", // plain text body
    html: "<b>Hello world?</b>", // html body
  });
});
```

## File upload (Back End)
Para esse utilizaremos as seguites tecnologias:
> [BackBlaze](https://www.backblaze.com/cloud-backup.html#af9uz7)
> [AWS-SDK](https://www.npmjs.com/package/aws-sdk)
> [Multer](https://www.npmjs.com/package/multer)

1. Na *BackBlaze* crie sua conta e em seguida crie um *Bucket*, e salve seus dados sensiveis.
2. Após isso, instale o *aws-sdk* e o *multer*.
3. Para o *Multer*, faça o seguinte:
    1. Crie um arquivo *Multer.js*
    2. Dentro dele faça a seguinte config
    ```
        const multer = require('multer');
        
        module.exports = multer({});
    ```
    > [color=#0fbbf9] Para utilizar coloque ele como middleware na rota que vai receber o *multipart*
    ```
    // Para receber somente um arquivo:
    app.post('/upload', 
        multer.single('NOME DO ARQUIVO'), 
        controller
    );

    // ou para multiplos arquivos

    app.post('/upload', 
        multer.array('NOME DO ARQUIVO'), 
        controller
    ); 
    ```
    > [color=#0fbbf9] Para acessar os arquivos enviados
    ```
        // Caso seja single
        
        req.file
        
        
        // caso seja array
        
        req.files
    ```
    
    
4. Configure suas credencias na *BackBlaze*
> [color=#0fbbf9] Na side bar, vá em *App Keys*
![](https://i.imgur.com/7vecoXP.png)

> [color=#1fee19] Clique no botão
![](https://i.imgur.com/TXgK1ac.png)

> [color=#fffd00] Escolha suas configurações
![](https://i.imgur.com/yPqg8zv.png)

> [color=#ff0044] Após isso, salve esses dados, pois após o *refresh* da página eles irão sumir
![](https://i.imgur.com/y9omkJ5.png)





5. Agora configuração do *aws-s3*, crie um arquivo chamado *aws.js* exportando o **s3**
    ```
    const aws = require("aws-sdk");

    const endpoint = new aws.Endpoint(process.env.ENDPOINT_S3);

    const s3 = new aws.S3({
      endpoint,
      credentials: {
        accessKeyId: process.env.KEY_ID,
        secretAccessKey: process.env.APP_KEY,
      },
    });
    
    ```
6. Exemplos:

> [color=#0fbbf9] Download - List
```
app.get('/arquivos', async (req, res) => {
    try{
        const arquivos = await s3.listObjects({
            Bucket: 'cubosacademy' //buscar do .env
        }).promise();
        
        const files = arquivos.Content.map((file) => {
            return {
                url: `https://${bucket_name}.${endpoint}/${file.key}`
                path: file.Key
            }
        })

        return res.json(files);
    }catch(e){
        return res.status(500).json('Erro interno no servidor');
    }
})
```

> [color=#0fbbf9] Upload-Single
```
app.post('/arquivos', 
    multer.single('photo'), 
    async (req, res) => {
        const { file } = req;
        
        try{
        
            const arquivo = await s3.upload({
                Bucket: 'cubosacademy', //buscar do .env
                Key: `imagens/${file.originalName}`,
                Body: file.Buffer,
                ContentType: file.mimeType
            }).promise()

            return res.status(200).json({
                url: arquivo.Location,
                path: arquivo.Key,
                
            });
        }catch(e){
            return res
                    .status(500)
                    .json('Erro interno no servidor');
        }
})
```

> [color=#0fbbf9] Upload-Multiple
```
app.post('/arquivos', 
    multer.array('photo'), 
    async (req, res) => {
        const { files } = req;
        
        try{
            const resultado = [];
            
            
            for(const file of files){
                const arquivo = await s3.upload({
                    Bucket: process.env.BUCKET, //buscar do .env
                    Key: `images/${file.originalname}`,
                    Body: file.buffer,
                    ContentType: file.mimetype,
                }).promise();
                
                resultado.push({
                    url: arquivo.Location,
                    path: arquivo.Key,
                })
            }

            return res.status(200).json(resultado);
        }catch(e){
            return res
                    .status(500)
                    .json('Erro interno no servidor');
        }
})
```
> [color=#0fbbf9] Remove

```
app.delete('/arquivo', async (req, res) => {
    const { file } = req.query;
    
    try{
        await s3.deleteObject({
            Bucket: 'cubosacademy',
            Key: file
        }).promise();
    
        return res.status(204).end()
    }catch(e){
            return res
                    .status(500)
                    .json('Erro interno no servidor');
        }
})
```

## Validations and best practices (Back-End)

> [color=#0fbbf9] Funções que retornam outras funções

```
const nome = (paramF1) => (paramF2) => console.log(paramF1, paramF2);

nome('william ')('krisley');

// william krisley
```

> [color=#0fbbf9] Isso é o mesmo que:

```
const nome = (paramF1) => {
    return function(paramF2){
     console.log(paramF1, paramF2);
    }
}

nome('william ')('krisley');

// william krisley
```

#### MiddleWare
 Após isso criaremos um middleware para fazer uma validação reutilizável.

```
const validateBody = (arrayProps) => (req, res, next) => {
    for(const item of arrayProps){
        if(!req.body[item]){
            res.status(400).json({
                message: ``O campo ${item} é obrigatório
            });
        }
    }
}


// na rota

    router.post('/user', validateBody(['nome', email, senha]), controller)
```

#### Libraries

Para validarmos diversas coisas como email, senha, cpf, etc; Teriamos que criar muito codigo o que dificultaria a manutenção  e reutilização, para isso utilizamos algumas bibliotecas.

