DEV Community: Edson Costa

[Boost]

Edson Costa — Mon, 01 Dec 2025 05:20:54 +0000

SOLID explicado com exemplos em Java — do jeito simples que todo dev gostaria de ter aprendido

Edson Costa for Devs Norte ・ Dec 1

#solidprinciples #java #programming #webdev

[Boost]

Edson Costa — Mon, 01 Dec 2025 05:06:17 +0000

SOLID explicado com exemplos em Java — do jeito simples que todo dev gostaria de ter aprendido

Edson Costa for Devs Norte ・ Dec 1

#solidprinciples #java #programming #webdev

SOLID explicado com exemplos em Java — do jeito simples que todo dev gostaria de ter aprendido

Edson Costa — Mon, 01 Dec 2025 05:05:50 +0000

Ao longo da minha jornada como desenvolvedor — principalmente vindo do desenvolvimento web — sempre ouvi falar sobre SOLID. Mas foi entrando de vez no desenvolvimento mobile que esses princípios começaram a fazer um sentido muito maior no meu dia a dia.

SOLID não é um conjunto de regras rígidas, e sim um guia de boas práticas para construir sistemas mais limpos, flexíveis e fáceis de manter.
E, para explicar isso, vou usar analogias simples e exemplos reais em Java, mostrando como cada princípio se aplica no código.

Vamos direto ao ponto.

🧱 O que é SOLID?

SOLID é um acrônimo formado por cinco princípios fundamentais da programação orientada a objetos:

S — Single Responsibility Principle
O — Open/Closed Principle
L — Liskov Substitution Principle
I — Interface Segregation Principle
D — Dependency Inversion Principle

A ideia central é simples: projetar software que seja fácil de entender, evoluir, testar e manter.

Agora, vamos ver cada princípio na prática.

1️⃣ Single Responsibility Principle (Responsabilidade Única)

“Uma classe deve ter apenas um motivo para mudar.”

Imagine uma classe que salva usuários e também envia e-mails.
Ela faz duas coisas — e isso é um problema.

❌ Exemplo que viola o SRP

public class UserService {

    public void saveUser(User user) {
        // salva no banco
    }

    public void sendWelcomeEmail(User user) {
        // envia e-mail
    }
}

Se qualquer parte falhar (e-mail, banco, regra de negócio), a classe inteira é afetada.

✔️ Exemplo seguindo o SRP

public class UserRepository {
    public void save(User user) {
        // salva no banco
    }
}

public class EmailService {
    public void sendWelcomeEmail(User user) {
        // envia e-mail
    }
}

Cada classe tem sua responsabilidade, e o código fica muito mais claro e testável.

2️⃣ Open/Closed Principle (Aberto para Extensão, Fechado para Modificação)

“Você deve poder adicionar novos comportamentos sem alterar código existente.”

✔️ Exemplo com descontos

public interface Discount {
    double apply(double price);
}

public class NoDiscount implements Discount {
    public double apply(double price) {
        return price;
    }
}

public class BlackFridayDiscount implements Discount {
    public double apply(double price) {
        return price * 0.5;
    }
}

Precisa de um novo tipo de desconto?

Crie uma nova classe.
Nenhuma linha das anteriores precisa mudar.

Isso é Open/Closed na prática.

3️⃣ Liskov Substitution Principle (Substituição de Liskov)

“Subclasses devem poder substituir suas classes base sem quebrar o comportamento esperado.”

❌ Exemplo que quebra o princípio

public class Bird {
    public void fly() {
        System.out.println("Voando...");
    }
}

public class Penguin extends Bird {
    @Override
    public void fly() {
        throw new UnsupportedOperationException("Pinguins não voam!");
    }
}

O contrato promete que todo pássaro voa, mas o pinguim não.
Isso quebra o comportamento esperado.

✔️ Exemplo correto

Separando o que pode voar do que não pode:

public interface Bird {
    void eat();
}

public interface FlyingBird extends Bird {
    void fly();
}

public class Eagle implements FlyingBird {
    public void eat() {}
    public void fly() {}
}

public class Penguin implements Bird {
    public void eat() {}
}

Agora, tudo faz sentido.

4️⃣ Interface Segregation Principle (Segregação de Interfaces)

“Nenhuma classe deve ser forçada a implementar métodos que não usa.”

❌ Exemplo errado

public interface Worker {
    void work();
    void eat();
}

public class Robot implements Worker {
    public void work() {}
    public void eat() {
        // robô não come...
    }
}

O robô é obrigado a implementar algo que não faz sentido para ele.

✔️ Exemplo correto

public interface Workable {
    void work();
}

public interface Eatable {
    void eat();
}

public class Robot implements Workable {
    public void work() {}
}

public class Human implements Workable, Eatable {
    public void work() {}
    public void eat() {}
}

Interfaces menores = classes mais limpas.

5️⃣ Dependency Inversion Principle (Inversão de Dependência)

“Dependa de abstrações, não de implementações concretas.”

❌ Exemplo errado

public class MySQLDatabase {
    public void connect() {}
}

public class UserService {
    private MySQLDatabase database = new MySQLDatabase();

    public void save(User user) {
        database.connect();
    }
}

O serviço está acoplado ao MySQL.
Se quiser trocar para Postgres, precisa alterar o código.

✔️ Exemplo correto

public interface Database {
    void connect();
}

public class MySQLDatabase implements Database {
    public void connect() {}
}

public class PostgresDatabase implements Database {
    public void connect() {}
}

public class UserService {

    private Database database;

    public UserService(Database database) {
        this.database = database;
    }

    public void save(User user) {
        database.connect();
    }
}

Agora, trocar o banco é só configurar outra implementação.

🎯 Conclusão

SOLID não é sobre “seguir regras”, e sim sobre facilitar sua vida como desenvolvedor.
Quanto mais seu sistema cresce, mais esses princípios fazem diferença.

Eles ajudam a criar:

código mais limpo,
classes mais coesas,
responsabilidades claras,
menos bugs,
mais testes,
e mais flexibilidade para evoluir o projeto.

Se você está trabalhando com Android, KMP ou qualquer arquitetura moderna (como MVVM), SOLID é um aliado poderoso.

Padronizando Commits com Commitizen e Husky

Edson Costa — Tue, 01 Oct 2024 00:03:02 +0000

Os commits bem estruturados são essenciais para manter a clareza e organização em projetos de desenvolvimento de software. Quando várias pessoas colaboram em um projeto, é crucial manter um padrão para mensagens de commit, facilitando a compreensão das alterações realizadas em um determinado momento. Neste artigo, exploraremos como padronizar commits usando as ferramentas Commitizen e Husky.

Por que padronizar commits?

Padronizar commits traz uma série de benefícios para equipes de desenvolvimento:

Clareza: Mensagens de commit bem estruturadas tornam mais fácil entender o propósito das alterações.
Rastreabilidade: Com commits padronizados, é mais simples rastrear a evolução do código ao longo do tempo.
Facilidade de Reversão: Commits bem documentados facilitam a identificação de alterações específicas, tornando mais fácil reverter mudanças indesejadas.
Colaboração: Padronizar commits promove uma melhor colaboração entre membros da equipe, pois todos seguem as mesmas convenções.

Introdução ao Commitizen e Husky

Commitizen é uma ferramenta que visa facilitar a criação de commits padronizados seguindo as convenções do Conventional Commits. Ele fornece uma interface interativa para guiar os desenvolvedores na criação de mensagens de commit consistentes.

Husky, por outro lado, é uma biblioteca que nos permite configurar ganchos (hooks) Git facilmente. Podemos usá-lo para executar scripts automatizados antes de certos eventos do Git, como commit, push e outros.

Passos para padronizar commits com Commitizen e Husky

Aqui estão os passos necessários para padronizar commits em seu projeto:

1. Instalação do Commitizen e Husky

Certifique-se de que o Node.js esteja instalado em seu sistema. Em seguida, instale o Commitizen e Husky como dependências de desenvolvimento em seu projeto:

npm install --save-dev commitizen husky

2. Configuração do Commitizen

Depois de instalar o Commitizen, você pode configurá-lo para seu projeto executando o seguinte comando:

npx commitizen init cz-conventional-changelog --save-dev --save-exact

Isso instalará o adaptador cz-conventional-changelog e configurará o Commitizen para usar o Conventional Commits.

3. Configuração do Husky

Com o Husky, podemos configurar ganchos Git para executar scripts antes de certos eventos. Para configurar o Husky, adicione o seguinte script ao seu package.json:

"husky": {
  "hooks": {
    "commit-msg": "commitlint -E HUSKY_GIT_PARAMS"
  }
}

Este script usa o commitlint para verificar se a mensagem de commit está em conformidade com as convenções especificadas.

4. Adicionar Configurações de Commitlint

O commitlint é uma ferramenta de validação de mensagens de commit baseada em regras. É comumente usado para garantir que as mensagens de commit sigam um formato específico. Você pode instalar o commitlint e as configurações do Conventional Commits usando:

npm install --save-dev @commitlint/{config-conventional,cli}

Em seguida, crie um arquivo commitlint.config.js na raiz do seu projeto e adicione o seguinte conteúdo:

module.exports = {extends: ['@commitlint/config-conventional']};

5. Usando Commitizen para commits

Agora que tudo está configurado, ao executar git commit, você será levado a uma interface interativa fornecida pelo Commitizen para criar mensagens de commit.

Conclusão

Padronizar commits é uma prática recomendada que promove clareza, rastreabilidade e colaboração em projetos de desenv

Automatizando Notificações via Telegram com GitHub Actions

Edson Costa — Tue, 01 Oct 2024 00:01:42 +0000

O GitHub Actions é uma ferramenta poderosa que permite automatizar tarefas dentro do fluxo de trabalho de desenvolvimento. Uma aplicação útil disso é a capacidade de enviar notificações para diferentes plataformas, como o Telegram, sempre que ocorrerem eventos específicos em seus repositórios do GitHub. Neste artigo, vamos explorar como configurar e utilizar o GitHub Actions para enviar notificações via Telegram.

O que é o GitHub Actions?

O GitHub Actions é um serviço de automação integrado diretamente no GitHub, permitindo que você crie fluxos de trabalho personalizados para automatizar processos de desenvolvimento, desde a construção e teste até a implantação e notificação.

Configurando o Telegram Bot

Antes de começarmos com o GitHub Actions, é necessário criar um bot no Telegram e obter seu token de acesso. Siga os passos abaixo:

Abra o Telegram e pesquise por BotFather.
Inicie uma conversa com o BotFather.
Use o comando /newbot para criar um novo bot.
Siga as instruções do BotFather, fornecendo um nome e um nome de usuário para o seu bot.
Após a criação, o BotFather irá fornecer um token de acesso para o seu bot. Mantenha esse token seguro, pois será usado posteriormente.

Configurando o GitHub Actions

Agora que temos o token do nosso bot, vamos configurar o GitHub Actions para enviar notificações para o Telegram sempre que ocorrerem eventos específicos em nosso repositório.

No seu repositório do GitHub, crie um diretório chamado .github/workflows se ainda não existir.
Dentro deste diretório, crie um arquivo YAML com o nome que desejar, por exemplo, telegram-notification.yml.
Adicione o seguinte conteúdo ao arquivo YAML:

name: Telegram Notification

on:
  push:
    branches:
      - main

jobs:
  telegram-notification:
    runs-on: ubuntu-latest
    steps:
      - name: Send Telegram Notification
        uses: appleboy/telegram-action@master
        with:
          to: ${{ secrets.TELEGRAM_TO }}
          token: ${{ secrets.TELEGRAM_TOKEN }}
          message: "New commit pushed to the repository."

Neste exemplo, configuramos o fluxo de trabalho para enviar uma notificação para o Telegram sempre que houver um push para a branch principal (main). Você pode personalizar os eventos e as branches conforme necessário.

Agora, precisamos adicionar as variáveis de ambiente TELEGRAM_TO e TELEGRAM_TOKEN como segredos em nosso repositório.

TELEGRAM_TO: Este é o ID do chat para o qual a mensagem será enviada. Você pode obter isso iniciando uma conversa com seu bot no Telegram e usando a API do Telegram para recuperar o ID do chat.
TELEGRAM_TOKEN: Este é o token de acesso que obtivemos anteriormente do BotFather.

Para adicionar esses segredos:

Navegue até as configurações do seu repositório no GitHub.
Selecione "Secrets" no menu lateral.
Clique em "New repository secret" e adicione as variáveis TELEGRAM_TO e TELEGRAM_TOKEN com seus valores correspondentes.

Testando o Fluxo de Trabalho

Com tudo configurado, você pode testar o fluxo de trabalho fazendo um push para a branch principal do seu repositório. Após o push, você deve receber uma notificação no Telegram informando sobre a nova alteração no repositório.

Conclusão

O GitHub Actions oferece uma maneira conveniente de automatizar tarefas repetitivas, como enviar notificações para plataformas externas como o Telegram. Neste artigo, vimos como configurar o GitHub Actions para enviar notificações via Telegram sempre que ocorrerem eventos específicos em um repositório do GitHub. Essa automação pode ajudar a manter equipes informadas sobre o progresso do desenvolvimento e a agilizar o fluxo de trabalho de desenvolvimento de software.

Turbinando sua Produtividade: Autocomplete e Personalização no Terminal do Windows

Edson Costa — Sat, 27 Apr 2024 13:52:16 +0000

Se você busca um terminal mais inteligente e visualmente atraente, capaz de antecipar seus comandos, reduzir a digitação repetitiva e oferecer um autocomplete eficaz, então você veio ao lugar certo! Vamos explorar como tornar o terminal do Windows uma ferramenta poderosa.

Começando

Windows Terminal: Comece instalando o Windows Terminal através da Microsoft Store ou baixando-o diretamente no GitHub. Ele oferece uma interface moderna e suporte para múltiplos terminais, como PowerShell, Command Prompt e WSL.

Oh My Posh: Essa é uma extensão que personaliza a aparência e o conteúdo da linha de comando. Por aqui, incluí o nome do usuário, o caminho da pasta, a branch atual, e a hora e uma experiência de terminal mais eficiente.

Para instalar o oh-my-posh, uma das opções é usar o winget, mas você pode usar o scoop, o próprio PowerShell ou chocolatey como mostrado na documentação:

winget install JanDeDobbeleer.OhMyPosh -s winget

Após instalar isso, o seu terminal precisa "saber" que deve usar o oh-my-posh. Para isso, vamos configurar o perfil do Powershell no VS Code. Basta executar o comando abaixo.

code $PROFILE

se não tiver o vscode instalado pode usar no bloco de notas da seguinte maneira:

notepad $PROFILE

Esse arquivo Microsoft.PowerShell_profile.ps1 que abriu é responsável por lê e executa os comandos desse arquivo a cada vez que o PowerSell é aberto. Nele, copie e cole o seguinte comando:

& ([ScriptBlock]::Create((oh-my-posh init pwsh --config "$env:POSH_THEMES_PATH\jandedobbeleer.omp.json" --print) -join "`n"))

Você pode trocar o "$env:POSH_THEMES_PATH\jandedobbeleer.omp.json" pela url do seu tema. Aqui você encotra diversos temas para o o Oh My Posh.

Salve e Recarregue o Terminal:
Salve o arquivo Microsoft.PowerShell_profile.ps1.
Feche e abra novamente o terminal ou recarregue o perfil do PowerShell.

Visualize as Mudanças:
Depois de recarregar o terminal, você deve ver as melhorias na linha de comando, incluindo informações como seu nome de usuário, diretório atual, ramificação do Git e hora

Antes de salvar meu terminal estava assim:

Após esse procedimento ficou assim:

Nerd Fonts: Para que os ícones do seu terminal apareçam, o oh-my-posh precisa que você use uma fonte compatível com eles, e uma das recomendações da própria aplicação é instalar uma fonte dentre as "Nerd Fonts".

Você pode baixar diretamente do repositório deles, ou usando um comando do oh-my-posh:

oh-my-posh font install

Terminal Icons: Essa é mais uma extensão para melhorar a aparência do terminal, acrescentando ícones do tipo de arquivo ou pasta que está na lista:

Para instalar, basta rodar os seguintes comandos no seu terminal:

Install-Module -Name Terminal-Icons -Repository PSGallery -Force
Import-Module Terminal-Icons

A cada vez que você abrir seu terminal, para ver o terminal Icons em funcionamento, você precisaria rodar novamente o comando Import-Module Terminal-Icons. Para que isso não seja necessário, basta acrescentar esse comando no arquivo de perfil do Powershell. (Lembra como faz isso? -> code $PROFILE).

Melhorias de Produtividade com Autocomplete

Agora, vamos falar sobre algumas extensões que são super úteis para facilitar o seu trabalho diário, especialmente quando estiver navegando entre as pastas.

Z: Esta é uma extensão de intellisense que consegue aprender com a forma como você navega entre as pastas. Isso significa que você não precisa mais digitar o caminho completo toda vez que quiser acessar uma pasta específica.

Como é um intellisense, o Z precisa de algumas navegações entre as pastas para "aprender" quais você acessa com mais frequência.
use assim:

Na primeira vez que usar use o nome da pasta completo. Como ex:

z crypto-trends

Na segunda vez em diante, você só precisa digitar parte do nome da pasta, e o Z já identificará a pasta desejada. Por exemplo, se você digitou "z crypto" anteriormente, na próxima vez pode digitar apenas:

PSReadLine O PSReadLine é um módulo do Powershell que permite o autocomplete de uma forma inteligente, também. Algumas configurações interessantes podem ser usadas para visualizar e navegar pelo histórico de comandos similares ao que você está digitando:

Para instalar, o comando é:

Install-Module -Name PSReadLine -AllowPrerelease -Force -SkipPublisherCheck

gora, para garantir que as opções de autocomplete apareçam como mostrado na imagem anterior, vamos adicionar alguns comandos ao seu perfil do PowerShell (aquele code $PROFILE).

Set-PSReadlineKeyHandler -Key Tab -Function MenuComplete

Set-PSReadLineOption -PredictionSource History
Set-PSReadLineOption -PredictionViewStyle ListView

Posh git O posh-git será seu novo melhor amigo. Com autocomplete para comandos do Git, você pode navegar entre branches e commits com facilidade, economizando tempo e esforço. Um simples "tab" após digitar git checkout, por exemplo, faz com que apareçam todas as opções de branches existentes no projeto.

Para usar, basta rodar o comando:

Install-Module posh-git -Scope CurrentUser -Force

Aliases Personalizados: Crie aliases para comandos frequentemente usados e aproveite o autocomplete para acessá-los rapidamente. Por exemplo:

Set-Alias g git

Segue abaixo o meu arquivo de perfil do PowerShell:

# Import-Module oh-my-posh ecarregar tema
& ([ScriptBlock]::Create((oh-my-posh init pwsh --config "$env:POSH_THEMES_PATH\jandedobbeleer.omp.json" --print) -join "`n"))
#Import-Module de Icones do terminal
Import-Module Terminal-Icons

#import do autocomplete por historico
Set-PSReadlineKeyHandler -Key Tab -Function MenuComplete
Set-PSReadLineOption -PredictionSource History
Set-PSReadLineOption -PredictionViewStyle ListView

# import do autocomplete do git
Import-Module Posh-Git

#Uso o  para não ficar poluido o terminal
clear-host

#Alias do git, não ter que digitar git no lugar só coloco g
Set-Alias g git

#Alias do chocolatey(Só use se tiver o chocolatey)
function Install-Choco {
    choco install $args
}

Set-Alias install Install-Choco

Atalhos do Terminal

Aqui estão alguns atalhos úteis para agilizar sua interação com o terminal:

Ctrl + Shift + t: Criar uma nova aba no Windows Terminal.
Ctrl + Tab: Alternar entre as abas no Windows Terminal.
Alt + Shift + -: Criar um pane na horizontal no Windows Terminal.
Alt + Shift + +: Criar um pane na vertical no Windows Terminal.
Ctrl + Shift + w: Remover um pane no Windows Terminal.
Alt + seta: Navegar entre os panes no Windows Terminal.
Ctrl + seta: Navegar entre as posições dentro de um pane no Windows Terminal.
Alt + Shift + seta: Redimensionar panes no Windows Terminal.
F11: Alternar entre o modo fullscreen e o modo normal no Windows Terminal.

Esses atalhos podem variar de acordo com a configuração do seu sistema ou outras extensões instaladas. Certifique-se de consultar a documentação do Windows Terminal para obter a lista completa de atalhos e funcionalidades.

Conclusão

Ao adotar as ferramentas e técnicas apresentadas, você não apenas transforma sua experiência de linha de comando, mas também eleva sua produtividade e eficiência a novos patamares. O Windows Terminal não é apenas uma janela para seus sistemas; é uma porta de entrada para um universo de possibilidades.

Personalizando sua linha de comando com o Oh My Posh, Nerd Fonts e Terminal Icons, você não apenas torna sua interação mais visualmente atraente, mas também mais informativa e funcional. A navegação rápida entre pastas com o Z, o autocomplete inteligente do PSReadLine e a facilidade de uso do posh-git simplificam suas tarefas diárias e liberam tempo para o que realmente importa: sua criatividade e inovação.

Portanto, mergulhe fundo, experimente, personalize e descubra como o terminal no Windows pode se tornar seu aliado mais poderoso. Combinando estilo, funcionalidade e eficiência, você está pronto para enfrentar qualquer desafio, abrir caminhos e alcançar novos horizontes em sua jornada digital.

Referências

Personalizando o terminal
Documentação do PSReadLine
Documentação do OhMyPosh
Alias do chocolatey
Documentação do NerdFonts
Atalhos do Terminal

Dominando os Desafios da Programação: Um Guia para os Erros Léxicos, Sintáticos e Semânticos

Edson Costa — Sun, 21 Apr 2024 15:12:16 +0000

Na jornada rumo à excelência na programação, enfrentamos uma série de desafios que testam nossa habilidade e perseverança. Entre estes desafios, destacam-se os erros léxicos, sintáticos e semânticos - obstáculos que podem comprometer a integridade e eficácia do código. Neste guia, vamos explorar esses erros em detalhes e discutir estratégias para identificá-los e corrigi-los de forma eficaz.

Erros Léxicos: Precisão na Linguagem da Programação

Os erros léxicos são como imperfeições na gramática de um idioma - pequenas discrepâncias que podem alterar completamente o significado de uma sentença. Na programação, essas imperfeições se manifestam quando palavras-chave são mal escritas ou símbolos são utilizados de forma inadequada. Considere o seguinte exemplo:

If x == 5:       # A primeira letra de "if" deveria estar minúscula
    print("Hello World")

Neste código, o erro léxico reside na letra maiúscula em "If", que deveria ser "if".

Erros Sintáticos: A Importância da Estruturação Correta

A sintaxe é a estrutura que define a gramática de uma linguagem de programação. Erros sintáticos ocorrem quando essa estruturação é violada, resultando em código que não pode ser interpretado corretamente pelo compilador ou interpretador. Considere o seguinte exemplo:

print "Erro de sintaxe")  # Esqueceu de colocar os parênteses para a função print

A ausência do ponto e vírgula no final da linha resulta em um erro sintático.

Erros Semânticos: Alinhando Intenção e Resultado

Embora o código possa estar gramaticalmente correto, ainda pode falhar em cumprir sua intenção original devido a erros semânticos. Esses erros ocorrem quando há uma discrepância entre a interpretação do programador e o comportamento real do programa. Considere o seguinte exemplo:

def media(lista):
    soma = 0
    for num in lista:
        soma += num
    return soma / len(lista)

lista = []
media(lista)     # Vai gerar uma exceção por tentar dividir por zero

A tentativa de calcular a média de uma lista vazia resulta em uma divisão por zero, um erro semântico.

Conclusão: Navegando com Precisão no Oceano da Programação

Identificar e corrigir erros em programação é uma habilidade essencial para qualquer desenvolvedor. Os erros léxicos, sintáticos e semânticos representam desafios significativos, mas compreendê-los nos capacita a enfrentá-los com confiança e eficácia. Que este guia sirva como uma ferramenta valiosa em sua jornada de desenvolvimento, ajudando-o a navegar com precisão no vasto oceano da programação.

Desenvolvendo um Bot do Telegram em Golang para Buscar Eventos da Comunidade Devs Norte no Sympla

Edson Costa — Sun, 21 Apr 2024 15:03:46 +0000

Este é um guia de como cria um bot para Telegram capaz de buscar e exibir eventos da Comunidade Devs Norte através da plataforma Sympla. Vamos mergulhar no processo de desenvolvimento passo a passo.

Pré-requisitos

Antes de começarmos, assegure-se de ter o Go instalado em seu sistema. Além disso, será necessário ter uma no Telegram.

Passo 1: Configuração do Ambiente

Crie um novo diretório para o seu projeto

inicialize um módulo Go usando o seguinte comando:

go mod init nome-do-seu-projeto

Certifique-se de ter as dependências necessárias instaladas:

go get github.com/joho/godotenv

go get github.com/mymmrac/telego

Passo 2: Configuração do Token

Agora, você precisa obter um token de autenticação do bot do Telegram para interagir com a API do Telegram. Siga estas etapas para obter o token:

Acesse o BotFather no Telegram.
Siga as instruções para criar um novo bot. Envie o comando /newbot e siga as instruções para fornecer um nome e um username para o seu bot.
Após concluir o processo de criação do bot, o BotFather irá fornecer um token de acesso para o seu bot.
Agora, crie um arquivo chamado .env no mesmo diretório do seu código e adicione o token como uma variável de ambiente.

TELEGRAM_BOT_TOKEN=seu_token_aqui

Substitua seu_token_aqui pelo token fornecido pelo BotFather.

Passo 3: Escrevendo o Código

Crie um arquivo main.go e coloque nele:
Importações das bibliotecas necessárias.
Definição das estruturas de dados necessárias para lidar com a resposta da API do Sympla.
Implementação da função NewBot para criar uma nova instância do bot do Telegram.
Implementação do método Start para iniciar o bot.
Implementação dos métodos para registrar os comandos do bot e lidar com eventos relacionados a eventos disponíveis e encerrados.
Implementação da função fetchSymplaEvents para fazer requisições à API do Sympla e obter eventos futuros ou passados.
Implementação da função intArrayToString para converter uma lista de inteiros em uma string.
Implementação da função formatEventsMessage para formatar a 9ensagem a ser enviada ao usuário com base nos eventos encontrados.
Função main que carrega as variáveis de ambiente, cria uma instância do bot e inicia sua execução.

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
    "os"
    "strings"

    "github.com/joho/godotenv"
    "github.com/mymmrac/telego"
    th "github.com/mymmrac/telego/telegohandler"
    tu "github.com/mymmrac/telego/telegoutil"
)

package main: Define que este arquivo faz parte do pacote principal do programa.
Importações: Importamos as bibliotecas necessárias para o funcionamento do bot, incluindo godotenv para lidar com variáveis de ambiente, telego para interagir com a API do Telegram e telegohandler e telegoutil para lidar com os eventos e mensagens do Telegram.

type Bot struct {
    bot   *telego.Bot
    bh    *th.BotHandler
    token string
}

Bot: Definimos uma estrutura Bot que contém o bot do Telegram, o manipulador de bot e o token de autenticação.

type SymplaResponse struct {
    Data []Event `json:"data"`
}

SymplaResponse: Define uma estrutura para armazenar a resposta da API do Sympla.

type Location struct {
    Country      string  `json:"country"`
    Address      string  `json:"address"`
    AddressAlt   string  `json:"address_alt"`
    City         string  `json:"city"`
    AddressNum   string  `json:"address_num"`
    Name         string  `json:"name"`
    Longitude    float64 `json:"lon"`
    State        string  `json:"state"`
    Neighborhood string  `json:"neighborhood"`
    ZipCode      string  `json:"zip_code"`
    Latitude     float64 `json:"lat"`
}

Location: Define uma estrutura para armazenar informações sobre a localização de um evento.

type Images struct {
    Original string `json:"original"`
    XS       string `json:"xs"`
    LG       string `json:"lg"`
}

Images: Define uma estrutura para armazenar URLs de imagens relacionadas a um evento.

type StartDateFormats struct {
    Pt string `json:"pt"`
    En string `json:"en"`
    Es string `json:"es"`
}
type EndDateFormats struct {
    Pt string `json:"pt"`
    En string `json:"en"`
    Es string `json:"es"`
}

StartDateFormats e EndDateFormats: Definem estruturas para armazenar formatos de data de início e fim de um evento.

type Event struct {
    Name             string           `json:"name"`
    Images           Images           `json:"images"`
    Location         Location         `json:"location"`
    StartDateFormats StartDateFormats `json:"start_date_formats"`
    EndDateFormats   EndDateFormats   `json:"end_date_formats"`
    URL              string           `json:"url"`
}

Event: Define uma estrutura para representar um evento, incluindo seu nome, imagens, localização, datas e URL.

func NewBot(token string) (*Bot, error) {
    bot, err := telego.NewBot(token, telego.WithDefaultDebugLogger())
    if err != nil {
        return nil, err
    }

    updates, err := bot.UpdatesViaLongPolling(nil)
    if err != nil {
        return nil, err
    }

    bh, err := th.NewBotHandler(bot, updates)
    if err != nil {
        return nil, err
    }

    return &Bot{
        bot:   bot,
        bh:    bh,
        token: token,
    }, nil
}

NewBot: Esta função cria uma nova instância do bot do Telegram, configura os manipuladores de atualização e retorna uma estrutura Bot inicializada.

func (b *Bot) Start() {
    defer b.bh.Stop()
    defer b.bot.StopLongPolling()

    b.registerCommands()

    b.bh.Start()
}

Start: Método que inicia o bot. Ele registra os comandos e inicia o manipulador de bot para receber atualizações do Telegram.

func (b *Bot) registerCommands() {
    b.registerBotCommand()
    b.registerEventCommands()
}

registerCommands: Método que registra todos os comandos disponíveis do bot.

func (b *Bot) registerBotCommand() {
    b.bh.Handle(func(bot *telego.Bot, update telego.Update) {
        infoMessage := `
👋 Bem-vindo ao Bot da Comunidade Devs Norte! 🚀

Este bot está aqui para ajudá-lo a encontrar os eventos mais recentes e emocionantes hospedados no Sympla pela nossa comunidade.

Para consultar os eventos disponíveis, basta digitar /disponiveis. E se estiver interessado nos eventos que já passaram, digite /encerrados.

Fique à vontade para explorar e participar dos eventos que mais lhe interessarem!😊
`

        _, _ = bot.SendMessage(tu.Message(
            tu.ID(update.Message.Chat.ID),
            infoMessage,
        ))
    }, th.CommandEqual("start"))
}

registerBotCommand: Método que registra o comando /start, que envia uma mensagem de boas-vindas ao usuário quando o bot é iniciado.

func (b *Bot) registerEventCommands() {
    b.registerAvailableEventsCommand()
    b.registerClosedEventsCommand()
}

registerEventCommands: Método que registra os comandos relacionados aos eventos disponíveis e encerrados.

func (b *Bot) registerAvailableEventsCommand() {
    b.bh.Handle(func(bot *telego.Bot, update telego.Update) {
        events, err := fetchSymplaEvents("future")
        if err != nil {
            fmt.Println("Erro ao buscar eventos:", err)
            return
        }
        message := formatEventsMessage(events)
        _, _ = bot.SendMessage(tu.Message(
            tu.ID(update.Message.Chat.ID),
            message,
        ))
    }, th.CommandEqual("disponíveis"))
}

registerAvailableEventsCommand: Método que registra o comando /disponiveis, que busca e exibe eventos futuros.

func (b *Bot) registerClosedEventsCommand() {
    b.bh.Handle(func(bot *telego.Bot, update telego.Update) {
        events, err := fetchSymplaEvents("past")
        if err != nil {
            fmt.Println("Erro ao buscar eventos:", err)
            return
        }
        message := formatEventsMessage(events)
        _, _ = bot.SendMessage(tu.Message(
            tu.ID(update.Message.Chat.ID),
            message,
        ))
    }, th.CommandEqual("encerrados"))
}

registerClosedEventsCommand: Método que registra o comando /encerrados, que busca e exibe eventos passados.

func fetchSymplaEvents(eventType string) ([]Event, error) {
    // Define os IDs dos organizadores
    organizerIDs := []int{3125215, 5478152}

    // Define o serviço a ser chamado na API do Sympla com base no tipo de evento
    service := "/v4/search"
    if eventType == "past" {
        service = "/v4/events/past"
    }

    // Monta o corpo da requisição
    requestBody := fmt.Sprintf(`{
        "service": "%s",
        "params": {
            "only": "name,images,location,start_date_formats,end_date_formats,url",
            "organizer_id": %s,
            "sort": "date",
            "order_by": "desc",
            "limit": "6",
            "page": 1
        },
        "ignoreLocation": true
    }`, service, intArrayToString(organizerIDs))

    // Faz a requisição HTTP para a API do Sympla
    resp, err := http.Post("https://www.sympla.com.br/api/v1/search", "application/json", strings.NewReader(requestBody))
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    // Lê a resposta da requisição
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        return nil, err
    }

    // Decodifica a resposta JSON em uma estrutura SymplaResponse
    var symplaResp SymplaResponse
    if err := json.NewDecoder(bytes.NewReader(body)).Decode(&symplaResp); err != nil {
        return nil, err
    }

    // Retorna os eventos encontrados na resposta
    return symplaResp.Data, nil
}

fetchSymplaEvents: Esta função faz uma requisição para a API do Sympla para buscar eventos, com base no tipo de evento (futuro ou passado), e retorna uma lista de eventos encontrados.

func intArrayToString(arr []int) string {
    strArr := make([]string, len(arr))
    for i, num := range arr {
        strArr[i] = fmt.Sprint(num)
    }
    return "[" + strings. Join(strArr, ",") + "]"
}

intArrayToString: Esta função converte uma lista de inteiros em uma string formatada para ser usada na construção do corpo da requisição para a API do Sympla.

func formatEventsMessage(events []Event) string {
    message := "#BOT Devs Norte 🤖\n\n\n"
    if events == nil || len(events) == 0 {
        message += "Ops... Nem um evento disponivel no momento, mas não fique triste logo estaremos fazendo mais eventos! 🥺\n\n\n"
    } else {
        message += "🎉 Eventos: 🎉\n\n\n"
        for _, event := range events {
            message += fmt.Sprintf("- %s\n  Local: %s\n  Data: %s\n  URL: %s\n \n\n\n", event. Name, event.Location.City, event.StartDateFormats.Pt, event.URL)
            message += "----------------------------------------\n\n\n"
        }
    }
    return message
}
}

formatEventsMessage: Esta função formata uma mensagem a ser enviada ao usuário com base nos eventos encontrados.

func main() {
    // Carrega as variáveis de ambiente do arquivo .env
    if err := godotenv.Load(); err != nil {
        fmt.Println("Erro ao carregar o arquivo .env:", err)
        os.Exit(1)
    }

    // Obtém o token do bot do Telegram das variáveis de ambiente
    token := os.Getenv("TELEGRAM_BOT_TOKEN")
    if token == "" {
        fmt.Println("Token do bot do Telegram não fornecido")
        os.Exit(1)
    }

    // Cria uma nova instância do bot e inicia sua execução
    bot, err := NewBot(token)
    if err != nil {
        fmt.Println(err)
        os.Exit(1)
    }
    bot.Start()
}

main: A função main é o ponto de entrada do programa. Ela carrega as variáveis de ambiente do arquivo .env, obtém o token do bot do Telegram, cria uma instância do bot e inicia sua execução.

Passo 5: Executar o Código

No diretório do projeto.
execute o código Go:

go run main. Go

Isso iniciará o bot do Telegram. Agora você pode acessar o bot no Telegram e interagir com ele usando os comandos /start, /disponiveis e /encerrados.

Você pode encontrar o código completo do projeto no repositório GitHub aqui.

Espero que essa explicação detalhada ajude a entender como o código funciona e como cada parte contribui para o funcionamento do bot do Telegram. Se tiver mais alguma dúvida ou precisar de mais alguma explicação, estou à disposição!