DEV Community: Weiglas

Me livrando das multas da biblioteca usando python

Weiglas — Tue, 12 Sep 2023 13:09:21 +0000

Eu confesso. Tem coisas que esqueço muito facilmente e é por isso que, se eu não configurar alguns lembretes no calendário, as datas passam voando por mim.

Acontece que certos esquecimentos doem no bolso, então minhas contas ficam no débito automático e assim minha vida funciona.

Porém, ainda tinha uma conta que toda semana me causava alguns reais a menos e eu ainda não tinha parado pra resolver isso: a conta da biblioteca.

Embora fosse tão fácil simplesmente entrar no aplicativo, ir na lista de livros emprestados, verificar o que já tinha passado do prazo e clicar no botão "renovar", eu só lembrava de fazer isso lá pelas duas horas da madrugada quando acordava de um sonho em que a bibliotecária confiscava a minha casa e prendia a minha família pois eu esqueci de devolver o livro de Cálculo na semana passada.

Então, ao invés de gastar alguns minutos configurando lembretes semanais para os livros que peguei, eu resolvi gastar algumas horas fazendo um script que renova todos os livros pra mim :)

O algorítmo

Em resumo, são necessários 4 passos:

Fazer o login na api do portal acadêmico
Armazenar o access_token para ser usado nas próximas requisições
Fazer a requisição que lista os livros que peguei emprestados
Verificar a data de devolução de cada livro, e
Caso seja a data de devolução, fazer a requisição que renova o livro

A api

O login

Para descobrir as urls da api do portal acadêmico, usei o DevTools do meu navegador. Então fiz o login e descobri que a requisição para fazer login é um POST para /apiapp/login2:

POST /apiapp/login2 HTTP/1.1
Host: portal.multivix.edu.br

No body da requisição são enviados meu login e senha.

{
    "username": "my-user",
    "password": "my-pass-123"
}

A lista de livros

Seguindo na descoberta das urls, fui até a página dos livros emprestados da biblioteca e vi que é um POST para /apiapp/api/biblioteca/listaemprestimorenovavel. O que recebo de resposta é um dicionário contendo os livros em três categorias: renováveis, não renováveis e renovados.

{
    "renovaveis": [
        {
            "codigo": 3751947,
            "ttl_nome": "Física I: mecânica",
            "autor": "YOUNG, Hugh D.",
            "mda_nome": "Livros",
            "dtemprestimo": "2023-09-03T00:00:00",
            "dtdevolucaoestimada": "2023-09-11T00:00:00",
            "renovado": true
        },
        {
            "codigo": 3749846,
            "ttl_nome": "Cálculo",
            "autor": "STEWART, James",
            "mda_nome": "Livros",
            "dtemprestimo": "2023-08-30T00:00:00",
            "dtdevolucaoestimada": "2023-09-06T00:00:00",
            "renovado": true
        }
    ],
    "naorenovaveis": [
        {
            "codigo": 0,
            "ttl_nome": "Variáveis complexas e aplicações 3ed., 2013",
            "autor": "ÁVILA, Geraldo",
            "mda_nome": "Livros",
            "dtemprestimo": "2023-09-05T00:00:00",
            "dtdevolucaoestimada": "2023-09-12T00:00:00",
            "renovado": false
        }
    ],
    "renovados": [
        {
            "codigo": 0,
            "ttl_nome": "Variáveis complexas e aplicações 3ed., 2013",
            "autor": "ÁVILA, Geraldo",
            "mda_nome": "Livros",
            "dtemprestimo": "2023-09-05T00:00:00",
            "dtdevolucaoestimada": "2023-09-12T00:00:00",
            "renovado": false
        }
    ]
}

A renovação do livro

Tendo um livro disponível para renovação, cliquei em renovar e então vi que a requisição para isso é um POST para /apiapp/api/biblioteca/renovaobra com o código do livro no body.

O script

Bom, como falei lá em cima, de forma resumida o script deve logar, listar os livros, verificar a data de devolução de cada livro e renovar, caso esteja na data de devolução. O processo principal será assim:

# main.py

def process(self):
    borrowed_books = self.api.list_borrowed_books()

    for book in borrowed_books:
        self.renew_if_is_due_date(book)

O primeiro método usado é o que lista os livros renováveis:

# api/library_apy

def list_borrowed_books(self):
        path = f'/api/biblioteca/listaemprestimorenovavel'

        try:
            response = self.request('POST', path, headers=headers)

            if response.status_code == 200:
                content = json.loads(response.text)
                borrowed_books = content.get('renovaveis')
                return borrowed_books
        except Exception as e:
            print(e)

E então, com os livros em mãos - ou melhor, em códigos -, percorro a lista de livros verificando se é necessário renoválo:

# main.py

def renew_if_is_due_date(self, book: dict):
    due_date = self.get_due_date(book)

    if self.now > due_date:
        book_code = book['codigo']
        self.api.renew_book(book_code)


def get_due_date(self, book: dict):
    unformatted_due_date = book.get('dtdevolucaoestimada')
    due_date = datetime.strptime(unformatted_due_date, '%Y-%m-%dT%H:%M:%S')
    return due_date

E o método renew_book() da api faz apenas um POST contendo o código do livro a ser renovado:

# api/library_apy

def renew_book(self, book_code):
    path = f'/api/biblioteca/renovaobra'

    body = {
        'codigo': book_code
    }

    try:
        response = self.request('POST', path, body=body)
        return response
    except Exception as e:
        print(e)

Aqui mostrei os passos principais do script de uma forma superficial. Ao final do post disponibilizo o link do github, caso você queira olhar com mais detalhes toda a estrutura do código.

A hospedagem

Para a hospedagem do meu código, resolvi usar o Lambda AWS com um gatilho para todar todo dia às 00:10h, uma vez que as datas de renovação são sempre às 00:00h.
Olhando nos logs, consigo verificar que está tudo rodando corretamente e eu não vou mais receber multas da biblioteca, hehe:

Bom, caso você queira olhar com mais detalhes o funcionamento do script, pode checar o repositório: https://github.com/Mr-Saxobeat/renew-my-borrowed-books

Fiquei muito satisfeito com a solução simples que cheguei e mais ainda por funcionar tão bem! Faz mais ou menos uma semana que este código tem rodado diariamente e eu já nem sei as datas de renovação dos livros hehe.

Caso você queira tirar alguma dúvida sobre o código pode entrar em cotato comigo por: weiglasribeiro@gmail.com

Publicado primeiro em: https://mr-saxobeat.github.io/2023/09/12/me-livrando-das-multas-da-biblioteca-usando-python.html

Automatizando o código da tarefa na mensagem de commit

Weiglas — Mon, 14 Nov 2022 20:57:58 +0000

Padrões de commits variam de empresa para empresa, mas todos têm o mesmo objetivo: organizar o histórico de modificações do repositório para que numa auditoria futura seja possível entender de onde veio uma modificação e a qual tarefa ela estava relacionada.

Em um padrão de empresa, por exemplo, pode ser necessário inserir o código da tarefa executada tanto no nome da branch, quanto nas mensagens de commit. Pois bem, imagina você ter que digitar uma mensagem e o código da tarefa toda vez... Ok, é possível copiar e colar este código, mas ainda sim eu pensei se não seria possível melhorar ainda mais. Então conheci uma funcionalidade do git que era justamente o que eu precisava para resolver o problema.

Git hooks

Git hooks são scripts executados quando certos eventos ocorrem. Existem vários:

pre-commit: é acionado antes mesmo de você digitar uma mensagem;
prepare-commit-msg: é acionado antes do editor de mensagem ser iniciado, mas depois da mensagem padrão ser criada;
commit-msg: recebe um parâmetro, que é o caminho para um arquivo temporário que contém a mensagem de commit já escrita.

Você pode ver mais sobre git hooks na documentação oficial.

Para nosso problema nós precisamos:

Extrair o código da tarefa a partir do nome da branch, no modelo: feature/COD-123-Uma-tarefa-da-pesada. Onde vamos extrair COD-123;
Digitar a mensagem de commit: Adiciona botao furta cor;
O git hook então fará o trabalho de juntar a mensagem com o código, tendo como resultado a seguinte mensagem: COD-123 - Adiciona botao furta cor.

Para isso vamos usar o prepare-commit-msg hook.

Então vamos lá:

Na sua pasta ~/.git/hooks crie um arquivo com nome prepare-commit-msg sem extensão
Configure o git para usar essa pasta para procurar os scripts a serem executados:
```
git config --global core.hooksPath ~/.git/hooks
```
Abra o arquivo ~/.git/hooks/prepare-commit-msg e adicione o seguinte script bash:

#!/bin/bash
#
# Inspeciona o nome da branch e verifica se contém um código da tarefa, (i.e COD-123).
# Se sim, a mensagem de commit será concatenada com "COD-123 - " no início.
#
# Útil para organizar o histórico git em grupos de commits junto a uma história do usuário.
#

BRANCH_NAME=$(git rev-parse --abbrev-ref HEAD 2>/dev/null)

# Remove o prefixo da branch (featute/, hotfix/, release/, etc)
BASE_BRANCH_NAME=$(echo $BRANCH_NAME | sed 's/[^\/]*\///')

# Certifica que BASE_BRANCH_NAME começa com um código de tarefa.
# SKIP_PREPARE_COMMIT_MSG pode ser usado para pular este hook, enquanto permite que outros continuem sendo acionados.
if [[ "$BASE_BRANCH_NAME" =~ (^[[:upper:]]{2,}-[[:digit:]]{1,}) ]] && [ "$SKIP_PREPARE_COMMIT_MSG" != 1 ]; then

  # Divide o resto do nome da branch pelo hífen '-'
  NAME_PARTS=($(echo "$BASE_BRANCH_NAME" | tr '-' '\n'))

  # Pega apenas as duas primeiras partes, que são exatamente "COD" e "123" e enfim os concatenam como "COD-123"
  COMMIT_PREFIX=$(echo "${NAME_PARTS[0]}-${NAME_PARTS[1]}")

  IS_PREFIX_IN_COMMIT=$(grep -c "$COMMIT_PREFIX" $1)

  # Certifica que COMMIT_PREFIX existe em BRANCH_NAME e não está já inserido na mensagem de commit
  if [[ -n "$COMMIT_PREFIX" ]] && ! [[ $IS_PREFIX_IN_COMMIT -ge 1 ]]; then
    sed -i.bak -e "1s~^~$COMMIT_PREFIX - ~" $1
  fi
fi

Dessa forma, ao fazer commit temos:

feature/COD-123-Uma-tarefa-da-pesada                                             
~\git\meu-projeto
❯ git commit -m "Adiciona botao furta cor"
[feature/COD-123-Uma-tarefa-da-pesada ffc707da] COD-123 - Adiciona botao furta cor
 1 file changed, 1 insertion(+), 1 deletion(-)

Este artigo foi adaptado do gist: https://gist.github.com/johncmunson/ca02a8027a923a7f4b2f662c67d6528c

Aprendendo em público: blockchain e criptomoedas

Weiglas — Mon, 29 Nov 2021 01:12:13 +0000

Tenho ouvido em todas minhas bolhas sociais sobre criptomoedas, bitcoin e NFT, mas não entendo nada do assunto. E penso que eu que trabalho com programação deveria ter um bom entendimento. Então já é hora de acabar com isso! Aqui neste primeiro post eu vou registrar minhas perguntas e respostas que for encontrando, tentando documentar a minha linha de raciocínio durante meu aprendizado.

As perguntas iniciais que tenho em mente são:

O que é e como funciona a blockchain?
O que é criptomoeda e bitcoin?
Por que criptomoeda tem valor?
Por que o valor das criptomoedas variam tanto?
Por que hoje as criptomoedas estão valendo muito?
O que é NFT?
Criptomoeda é realmente a moeda do futuro ou existe outra solução?

Então vamos começar entendendo o que é blockchain.

Bom, depois de ler alguns artigos[1][2] e assistir alguns vídeos[3], o que tenho a dizer com minhas palavras é que blockchain é uma base de dados que registra o histórico de transações e que armazena esses dados de forma descentralizada, ou seja, esses históricos não ficam armazenados em apenas um computador, mas sim em todos os computadores que utilizam esse banco de dados.

Aqui vai minha primeira epifania: o blockchain é uma tecnologia inicialmente independente do bitcoin ou qualquer criptomoeda.

Vou dar um exemplo prático: Joana tem um carro e ela vai vendê-lo para Maria. Para isso, após o negócio fechado entre as duas, Joana deve fazer todo o processo de transferência de titularidade do veículo no Departamento Estadual de Trânsito (DETRANs), que detem um banco de dados nacional onde tem o registro de que Joana é a atual proprietária do carro. Ao fazer a transferência, vai ficar registrado no histórico do veículo que “Joana vendeu o carro para Maria”.

Perceba uma coisa: o banco de dados é de propriedade do DETRAN e só ele pode verificar que seus dados não foram corrompidos. E se Paulo, um hacker muito talentoso, quisesse passar o carro de Joana para seu próprio nome? Ele simplesmente invadiria o sistema do DETRAN e trocaria o registro para seu nome e pronto, ninguém contestaria os dados.

O blockchain resolve esses dois principais problemas: a centralização e a corrupção dos dados.

Vamos entender como o blockchain descentraliza o armazenamento dos dados.

Funcionaria assim: cada pessoa teria uma cópia completa do banco de dados em seu computador e cada mudança que acontecesse seria refletida no computador de todo mundo através da internet. Então no exemplo acima, a Joana, ao invés de ir no DETRAN, simplesmente abriria o seu computador, entraria com sua conta e senha no sistema e alteraria a titularidade do seu carro para Maria e essa transação surtiria efeito no computador de todo mundo.

Por que a descentralização é uma coisa boa?
Geralmente, a descentralização sempre é bom pois assim o controle não fica na mão de apenas uma instituição ou pessoa. No caso de um banco de dados, também há o fato de que se este fosse armazenado num único servidor do DETRAN ele estaria sujeito a perda de todos os seus registros caso acontecesse algum acidente corrompendo seus dados. Mas tendo uma cópia completa em cada computador, a corrupção dos dados teria que ocorrer em todos os computadores.

E sobre a corrupção dos dados?
Blockchain significa corrente de blocos e, assim como em uma corrente, a quebra de um único nó compromete a corrente inteira.

O que são esses blocos de dados?
Cada bloco de dados da blockchain é composto por três fatores:
Os seus dados: as transações, como por exemplo “Joana vendeu o carro para Maria”.
A sua impressão digital, que em computação é chamada de hash.
E a impressão digital (hash) do bloco anterior.

Sendo assim, a corrente é formada pela ligação que cada bloco tem com o bloco anterior.
Aí você me pergunta: tá, mas o que é esse tal de hash? Pois bem, o hash é uma cadeia de 64 letras e números que é formada a partir de um dado. No nosso caso, estamos usando o dado “Joana vendeu o carro para Maria”. O hash para o nosso dado é o seguinte (gerado aqui):

1d4140f617daa6fca841970bc05654f99a8e4ff37cda82acfb6331c5d54ae383

Bem doido, né? O que faz o hash ser tão especial é que existe um único para cada dado, seja ele qual for. Isso é calculado através de um algoritmo chamado SHA256, que eu ainda não sei como funciona, mas qualquer dia vou querer dar uma olhada mais a fundo.

Então voltando à cadeia: se um bloco tem o seu hash e o do bloco anterior, caso haja alguma alteração no bloco anterior, todos os blocos posteriores vão acusar que tem coisa errada ali. Por isso a segurança contra corrupção.

Se você for neste link, pode ver qual o hash gerado para o dado que escrever.

Vou experimentar mais um pouco: meu primeiro bloco de dados vai ter as seguintes informações:
O seu dado: “Joana comprou um carro”;
O hash do bloco anterior vai ser “00000” pois não existe bloco anterior.
Seu próprio hash: 6dece74df8d16ac04568a4f6374daa7e0647a25662813d99bd7eb47c7689a1b7

Agora meu segundo bloco vai ter as seguintes informações:
Joana vendeu seu carro para Maria
Hash anterior: 6dece74df8d16ac04568a4f6374daa7e0647a25662813d99bd7eb47c7689a1b7
Seu Hash: 0a3353754007af8414bfb31ad4aca356120151453686e517fdd2e82d09c3d278

Se o primeiro bloco tiver qualquer alteração, o seu hash vai mudar. E como o segundo bloco tem registrado o hash original do primeiro bloco, ele vai comparar com o hash alterado e vai acusar que tem informação alterada ali!
Então dessa forma a cadeia de blocos garante que seus dados não foram corrompidos.

Navegando por este site de demonstração de blockchain[4], você pode encontrar as páginas que demonstram melhor e também os vídeos de explicação, que eu achei ótimos vale dar uma olhada.

Ao assistir os vídeos que falei ali em cima, me deparei com alguns outros conceitos:

A assinatura de bloco
O número Nonce
E a mineração de um bloco

Esses três conceitos são interligados, então serão explicados juntos.

Sabemos que uma rede blockchain não depende de um único servidor, sendo assim, qualquer um com acesso a rede pode gravar dados na blockchain. É claro que cada um deve ter sua conta e senha para fazer qualquer operação, mas mesmo assim, usuários maliciosos podem fazer uma coisa chamada ataque de negação de serviço (também conhecido como DoS Attack, um acrônimo em inglês para Denial of Service). Esse tipo de ataque consiste em enviar vários dados para a rede fazendo com que esta se sobrecarregue e então “trave” ou pare de responder. E para prevenir este ataque a blockchain requer que quem quer enviar dados à rede tenha um trabalho computacional. Aqui nos deparamos com o conceito de “Prova de trabalho”.

Essa prova de trabalho consiste em encontrar um número que, ao ser adicionado ao corpo do bloco a ser criado, gere um hash específico.

Este “número mágico” é chamado de nonce[5], acrônimo para number once, ou “número único”, pois ele realmente é o único número que pode satisfazer uma condição.

E o ato de procurar esse número é chamado de mineração.

Vamos voltar ao exemplo de Joana vendendo seu carro.

Na imagem acima, que é do site já citado para demonstrações de blockchain, Temos um bloco que tem número 1, tem o nonce 72608, o dado “Joana vendeu seu carro para Maria” e o seu hash. O bloco está vermelho pois o seu hash não satisfaz a condição, que no caso é que “o hash deve começar com quatro dígitos zeros”. Essa condição varia com o tempo para dificultar ou facilitar a prova de trabalho.
Então, para chegar ao hash que satisfaça a condição, o computador vai testando vários números que, junto com o dado e o número do bloco, vão gerar um hash que inicie com quatro zeros.

Ao clicar no botão “mine”, vamos minerar e chegar ao resultado correto.

Agora nosso bloco está verde, indicando que foi validado, ou assinado, e o seu nonce é 62449, fazendo com que o seu hash inicie com 4 dígitos zeros.

Se você for no site e testar, verá que ao clicar em “Mine” demora pelo menos um segundo para chegar ao resultado correto, ou seja, não é um número fácil de ser calculado e isso impede que alguém com más intenções tente publicar milhares de blocos de uma só vez na rede.

E aqui me veio um esclarecimento bem grande: a mineração é necessária apenas por causa da camada de segurança. O que eu quero dizer é que, a “lógica base” da blockchain, que é registra dados em cadeia, não precisa encontrar um número que satisfaça uma condição. Isso era uma coisa que me deixava beem confuso esse conceito de minerar bitcoin. Olha só, na real o que é minerado é o nonce!

Bom, acredito que aqui já cheguei num novo nível de entendimento sobre a blockchain e com novas perguntas que tentarei entender no próximo post:
Se o que é minerado é o nonce, por que existe a confusão de “minerar bitcoin”?
O que acontece se dois computadores descobrirem o noce ao mesmo tempo?

Fico por aqui e até o próximo post!

[1] https://pt.wikipedia.org/wiki/Blockchain
[2] https://blog.nubank.com.br/o-que-e-blockchain/
[3] https://www.youtube.com/watch?v=dkElPTevoR4
[4] https://andersbrownworth.com/blockchain/
[5] https://youtu.be/rZaGbEcs7ag