

# #8 Desafio de Programação: Encurtador de Links

## **Descrição**
Desenvolva um sistema completo para encurtar links, utilizando **Docker**, **Traefik** como reverse proxy, e um sistema que **identifique URLs encurtadas automaticamente** com base no domínio e estrutura da URL. O desafio inclui funcionalidades de gerenciamento de links, redirecionamento dinâmico e registro de métricas.

---

## **Objetivo**
1. Criar um sistema que permita encurtar links e gerenciá-los.
2. Permitir que links encurtados sejam redirecionados com base apenas no **short_code** presente na URL.
3. Utilizar **Traefik** como reverse proxy para roteamento dinâmico.
4. Configurar todo o ambiente com **Docker Compose** para facilitar o deploy.

---

## **O que será Aprendido**
1. **Redirecionamento Inteligente:**
   - Processar URLs encurtadas diretamente pelo domínio e path.
2. **APIs Avançadas:**
   - Criar endpoints RESTful para gerenciamento de links.
3. **Docker e Containers:**
   - Orquestrar serviços e ambiente de produção com Docker Compose.
4. **Traefik como Reverse Proxy:**
   - Configurar roteamento dinâmico sem rotas adicionais.
5. **Métricas Avançadas:**
   - Registro de acessos (IP, agente de usuário e data/hora).

---

## **Arquitetura**

### **Diagrama de Arquitetura**
![Fluxo do Encurtador de Links](/assets/challenges/encurtador-de-links/fluxo-encurtador-links.png)

---

## **Especificações Técnicas**

### **Backend**
- **Banco de Dados:** PostgreSQL, MySQL, SQL.
- **Reverse Proxy:** Traefik.
- **Ambiente:** Docker e Docker Compose.
- **Métricas:** Contador de cliques, rastreamento de IPs e agente de usuário.

---

## **Endpoints e Payloads**

### 1. **Criar Link Curto**
- **POST** `/api/shorten`
- **Body:**
  ```json
  {
    "url": "https://exemplo.com/minha-url"
  }
  ```
- **Response:**
  ```json
  {
    "short_url": "https://short.local/abc123",
    "original_url": "https://exemplo.com/minha-url"
  }
  ```

---

### 2. **Redirecionamento**
- O sistema reconhece o formato `https://short.local/{short_code}` automaticamente.
- Ao acessar `https://short.local/abc123`, a requisição é roteada para a API, que:
  1. Busca o `short_code` no banco.
  2. Redireciona o cliente para a URL original com código **`302 Found`**.

---

### 3. **Listar Links Criados**
- **GET** `/api/links`
- **Response:**
  ```json
  [
    {
      "short_url": "https://short.local/abc123",
      "original_url": "https://exemplo.com",
      "clicks": 42
    },
    {
      "short_url": "https://short.local/xyz789",
      "original_url": "https://outra.com",
      "clicks": 15
    }
  ]
  ```

---

### 4. **Excluir Link Curto**
- **DELETE** `/api/links/{short_code}`
- **Response:**
  ```json
  {
    "message": "Link deleted successfully"
  }
  ```

---

## **Resultados Esperados**
1. **Encurtador Funcional:**
   - Gerar links curtos e redirecionar automaticamente sem necessidade de rotas explícitas.
2. **Integração com Traefik:**
   - Roteamento dinâmico baseado em `short_code`.
3. **Métricas Avançadas:**
   - Registro de IPs, agentes de usuário e datas de acesso.
4. **Ambiente Contenerizado:**
   - Docker Compose configurado para fácil deploy.

---

Boa sorte com o desafio! 🚀


Desenvolva um sistema completo de encurtador de links com Docker, Traefik e métricas avançadas. Aprenda a gerenciar redirecionamentos e automatizar o deploy com Docker Compose

#8 Encurtador de Links



# #7 Desafio de Programação: Controle de Assinaturas

## **Descrição**
Desenvolva uma API para gerenciar assinaturas em um sistema SaaS ou serviço de streaming. A API deve lidar com planos de assinaturas, cobrança recorrente, upgrades/downgrades e gerenciamento do ciclo de vida das assinaturas. O sistema será orientado a eventos, utilizando uma fila de mensagens para processar atualizações de cobrança e assinaturas.

---

## **Objetivo**
1. Criar uma API para gerenciar assinaturas e seus planos.
2. Implementar filas para processar eventos de cobrança e atualizações.
3. Atualizar assinaturas automaticamente com base nos eventos processados.
4. Fornecer métricas básicas sobre assinaturas e planos.

---

## **O que será Aprendido**
1. **Mensageria:**
   - Uso de filas (RabbitMQ ou Kafka) para processamento assíncrono de eventos.
2. **Gerenciamento de Assinaturas:**
   - Criação, atualização e cancelamento de assinaturas.
3. **Arquitetura Orientada a Eventos:**
   - Como estruturar um sistema desacoplado utilizando eventos.
4. **Modelagem de Dados:**
   - Estruturas para planos, assinaturas e eventos de pagamento.

---

## **Arquitetura**

### **Diagrama de Fluxo**

![Fluxo Sistema de Assinatura](/assets/challenges/controle-de-assinaturas/fluxo-sistema-assinatura.png)

---

## **Especificações Técnicas**
### **Backend**
- **Mensageria:** RabbitMQ, Kafka ou Redis Streams.
- **Banco de Dados:** PostgreSQL ou MongoDB.

### **Componentes Adicionais**
- **Worker de Processamento:**
  - Processa eventos da fila, como atualizações de cobrança.
- **Fila de Mensagens:**
  - Armazena eventos para processamento assíncrono.

---

## **Endpoints e Payloads**

### 1. **Gerenciamento de Assinaturas**
#### **Criar Assinatura**
- **POST** `/api/subscriptions`
- **Body:**
  ```json
  {
    "plan_id": "plan_12345",
    "customer_email": "cliente@email.com"
  }
  ```
- **Response:**
  ```json
  {
    "subscription_id": "sub_67890",
    "status": "pending",
    "next_billing_date": "2025-02-01"
  }
  ```

#### **Atualização Automática**
- Após a criação, a assinatura entra na fila como um evento do tipo `subscription_created`.

---

### 2. **Webhooks**
#### **Atualização de Cobrança**
- **POST** `/api/webhooks/payment`
- **Body:**
  ```json
  {
    "subscription_id": "sub_67890",
    "event": "payment_success",
    "amount": 29.99,
    "date": "2025-01-01"
  }
  ```
- **Processo:**
  1. A API coloca o evento na fila de mensagens.
  2. O worker processa o evento e atualiza a assinatura no banco.

---

### 3. **Relatórios**
#### **Obter Métricas de Assinaturas**
- **GET** `/api/reports/subscriptions`
- **Response:**
  ```json
  {
    "total_active": 120,
    "total_cancelled": 15,
    "plans": [
      {
        "plan_id": "plan_12345",
        "name": "Basic Plan",
        "active_subscriptions": 80
      },
      {
        "plan_id": "plan_54321",
        "name": "Premium Plan",
        "active_subscriptions": 40
      }
    ]
  }
  ```

---

## **Processos com Mensageria**

### **1. Processamento de Webhook**
1. O provedor de pagamentos envia um evento de pagamento para o webhook.
2. A API valida o evento e o coloca na fila de mensagens.
3. O worker consome o evento e atualiza o status da assinatura no banco.

### **2. Processamento de Assinatura**
1. Após a criação de uma assinatura, um evento `subscription_created` é colocado na fila.
2. O worker verifica a assinatura e simula o envio para o sistema de cobrança.

---

## **Modelo de Dados**

### **Tabelas**
1. **Plans**
   - `id`: UUID.
   - `name`: Nome do plano.
   - `price`: Preço do plano.
   - `billing_cycle`: Mensal ou anual.

2. **Subscriptions**
   - `id`: UUID.
   - `plan_id`: Relacionamento com a tabela de planos.
   - `customer_email`: Email do cliente.
   - `status`: Pendente, Ativa, Suspensa, Cancelada.
   - `next_billing_date`: Data do próximo pagamento.

3. **Events**
   - `id`: UUID.
   - `type`: subscription_created, payment_success, payment_failed.
   - `data`: Dados do evento (JSON).
   - `processed`: Boolean indicando se o evento já foi processado.

---

## **Resultados Esperados**
1. **API Funcional:** Capaz de gerenciar assinaturas e lidar com planos.
2. **Mensageria:** Processamento assíncrono de eventos utilizando filas.
3. **Automação:** Atualização automática de status com base em eventos.
4. **Relatórios:** Métricas básicas sobre assinaturas e planos.

---

## **Publicação**
1. Configure RabbitMQ, Kafka ou Redis em um ambiente local ou na nuvem.
2. Teste os endpoints com ferramentas como Postman ou Insomnia.
3. Realize o deploy em serviços como Heroku, AWS ou Google Cloud.

---

Boa sorte com o desafio! 🚀


Desenvolva uma API para gerenciar assinaturas com mensageria, cobrindo planos, cobrança recorrente e atualizações automáticas com eventos assíncronos

#7 Controle de Assinaturas



# #6 Desafio de Programação: Amigo Secreto

## Descrição
Este desafio propõe a recriação de um sistema para sorteio de Amigo Secreto utilizando IndexDB para armazenamento local. O objetivo é criar uma aplicação simples, funcional e offline-friendly, que permita organizar e realizar sorteios de forma intuitiva. É ideal para aprender sobre tecnologias modernas de front-end e persistência de dados no navegador.

Você pode conferir um exemplo do projeto no post original: [Sorteio de Amigo Secreto](https://racoelho.com.br/posts/sorteio-de-amigo-secreto).

Ou uma demo funcionando nesse link: [Amigo Secreto](https://secret-santa.racoelho.com.br/).

---

## Objetivo
1. Criar uma aplicação web para sorteio de Amigo Secreto.
2. Implementar o armazenamento de dados localmente com **IndexDB**.
3. Publicar a aplicação para uso real.

---

## O que será Aprendido
1. **Persistência de Dados no Front-end:**
   - Como usar o **IndexDB** para salvar informações localmente.
2. **Manipulação de Arrays e Objetos:**
   - Técnicas para criar e embaralhar listas para o sorteio.
3. **Desenvolvimento Web:**
   - Uso de HTML, CSS e JavaScript para criar interfaces interativas.
4. **Publicação de Projetos:**
   - Como hospedar uma aplicação web usando GitHub Pages ou outro serviço.

---

## Especificações do Desafio

### Funcionalidades Obrigatórias
1. **Cadastro de Participantes**
   - Adicionar participantes com nome e email.
   - Listar participantes na tela.

2. **Sorteio do Amigo Secreto**
   - Realizar o sorteio embaralhando a lista de participantes.
   - Garantir que nenhum participante seja seu próprio amigo secreto.
   - Mostrar o resultado de forma segura (ex.: exibir apenas o amigo secreto de cada participante mediante interação).

3. **Armazenamento Local**
   - Salvar os participantes no **IndexDB**.
   - Manter os dados persistentes mesmo ao recarregar a página.

4. **Interface Amigável**
   - Design simples e funcional para cadastro, sorteio e visualização dos resultados.


---
### Telas
Como o projeto é front-end apenas, as operações são feitas localmente, mas seguem uma estrutura lógica:

- Adicionar Participante: Salva no IndexDB.
- Listar Participantes: Recupera do IndexDB.
- Realizar Sorteio: Gera o resultado no front-end e salva no IndexDB.
- Visualizar Resultados: Recupera os dados do sorteio e exibe para o usuário.

---

### Funcionalidades Opcionais (Diferenciais)
1. **Envio de Resultados**
   - Implementar envio de emails para notificar os participantes com seus amigos secretos (usando serviços como EmailJS ou APIs de email).
2. **Temas Personalizáveis**
   - Adicionar a possibilidade de mudar a aparência da aplicação com temas diferentes.
3. **Histórico de Sorteios**
   - Salvar múltiplos sorteios no **IndexDB** e permitir consulta posterior.

---

## Sugestões de Stack

### Frontend
- **HTML5, CSS3 e JavaScript:**
  - Criação da interface e funcionalidades básicas.
- **Frameworks Opcionais:** 
  - **React.js** ou **Vue.js** para componentes reativos.
  - **Tailwind CSS** ou **Bootstrap** para estilização rápida.

### Armazenamento
- **IndexDB:** 
  - API nativa do navegador para armazenamento local de dados.
- **Alternativa:** LocalStorage (menos recomendado para volumes maiores de dados).

### Publicação
- **GitHub Pages:** Hospedar a aplicação de forma gratuita.
- **Netlify** ou **Vercel:** Opções modernas para deploy.

---

## Especificações de Arquitetura

### Frontend
1. **Páginas Principais:**
   - Cadastro de Participantes.
   - Página de Sorteio.
   - Tela de Resultados.
2. **Interatividade:**
   - Manipulação do DOM para adicionar e exibir participantes.
   - Botão para sortear e exibir resultados.


## Fluxo de Uso
1. **Cadastro de Participantes**
   - Usuário adiciona os nomes e emails de cada participante.
   - Os dados são salvos localmente no IndexDB.
2. **Sorteio**
   - Ao clicar no botão "Sortear", o sistema embaralha os participantes e salva os resultados.
3. **Visualização**
   - Cada participante pode acessar seu resultado individualmente.
4. **(Opcional) Notificação**
   - Resultados são enviados por email automaticamente.

---

## Publicação
1. **Preparação**
   - Configure o repositório no GitHub.
   - Use ferramentas como Webpack ou Vite (opcional) para otimizar o projeto.
2. **Deploy**
   - **GitHub Pages:** Configure o repositório para deploy automático.
   - **Netlify/Vercel:** Faça o upload da aplicação com suporte a builds automáticas.
3. **Domínio Personalizado**
   - Opcionalmente, configure um domínio customizado para a aplicação.

---

## Nível do Desafio
- **Intermediário:** Requer conhecimentos básicos de JavaScript, manipulação de dados e APIs do navegador.
- **Avançado (com diferenciais):** Inclui envio de emails, histórico de sorteios e exportação de dados.

---


Boa sorte com o desafio! 🚀


Desenvolva um sistema de sorteio de Amigo Secreto usando IndexDB para armazenar participantes e resultados.

#6 Amigo Secreto



# #5 Desafio de Programação: Autenticador como Provedor de Identidade (IDP)

## Descrição
Este desafio propõe o desenvolvimento de um autenticador simples que atua como um Provedor de Identidade (IDP). O sistema deve permitir que usuários se registrem, façam login e autentiquem-se em serviços externos, redirecionando-os após a autenticação. É ideal para aprender os fundamentos de autenticação, segurança, e protocolos como OAuth 2.0, além de explorar integrações futuras.

---

## Objetivo
Criar um sistema de autenticação que:
1. Permita registro, login e recuperação de senha.
2. Gere tokens JWT para autenticação e acesso a áreas protegidas.
3. Redirecione usuários autenticados para a aplicação cliente que requisitou o login.
4. Implemente um fluxo básico de OAuth 2.0 para serviços externos.

---

## Especificações de Arquitetura

### Frontend
- **Tecnologias:** HTML, CSS e JavaScript (ou frameworks modernos como React, opcional).
- **Páginas principais:**
  1. Registro
  2. Login
  3. Perfil do Usuário (opcional)

### Backend
- **Endpoints:**
  - `/api/auth/register`: Registro de usuários.
  - `/api/auth/login`: Login e geração de JWT.
  - `/api/auth/verify-email`: Verificação de email.
  - `/api/auth/reset-password`: Solicitação de recuperação de senha.
  - `/api/auth/new-password`: Redefinição de senha.
  - `/api/auth/oauth`: Início do fluxo OAuth 2.0.
  - `/api/auth/callback`: Callback para redirecionar usuários autenticados.

### Banco de Dados
- **Tecnologia:** MySQL ou PostgreSQL.
- **Tabelas:**
  1. **Users**:
     - `id` (UUID, Primary Key)
     - `name` (String)
     - `email` (String, único)
     - `password` (Hash)
     - `is_verified` (Boolean)
  2. **Tokens** (opcional):
     - `user_id` (Foreign Key)
     - `token` (JWT)
     - `expires_at` (Timestamp)

### Segurança
- Hash de senhas com `bcrypt`.
- Tokens JWT com expiração curta e suporte a refresh tokens.
- Proteção contra ataques de força bruta com limites de requisições.

---

## Endpoints

### Autenticação
1. **Registrar Usuário**
   - **POST** `/api/auth/register`
   - Body:
     ```json
     {
       "name": "João Silva",
       "email": "joao@example.com",
       "password": "senhaSegura123"
     }
     ```
   - Response:
     ```json
     {
       "message": "Usuário registrado. Verifique seu email para ativar a conta."
     }
     ```

2. **Login**
   - **POST** `/api/auth/login`
   - Body:
     ```json
     {
       "email": "joao@example.com",
       "password": "senhaSegura123"
     }
     ```
   - Response:
     ```json
     {
       "token": "jwt-token",
       "redirect_url": "https://appcliente.com/dashboard"
     }
     ```

3. **Verificar Email**
   - **GET** `/api/auth/verify-email`
   - Query Params:
     - `token=<verification_token>`
   - Response:
     ```json
     {
       "message": "Email verificado com sucesso."
     }
     ```

4. **Recuperar Senha**
   - **POST** `/api/auth/reset-password`
   - Body:
     ```json
     {
       "email": "joao@example.com"
     }
     ```
   - Response:
     ```json
     {
       "message": "Email de recuperação enviado."
     }
     ```

5. **Redefinir Senha**
   - **POST** `/api/auth/new-password`
   - Body:
     ```json
     {
       "token": "reset-token",
       "new_password": "novaSenha123"
     }
     ```
   - Response:
     ```json
     {
       "message": "Senha redefinida com sucesso."
     }
     ```

### OAuth 2.0
1. **Início do Fluxo OAuth**
   - **GET** `/api/auth/oauth`
   - Query Params:
     - `client_id`
     - `redirect_uri`
   - Response:
     Redireciona o usuário para a página de login.

2. **Callback**
   - **GET** `/api/auth/callback`
   - Query Params:
     - `code`
     - `state`
   - Response:
     ```json
     {
       "access_token": "jwt-token",
       "redirect_url": "https://appcliente.com/dashboard"
     }
     ```

---

## Fluxo de Uso

1. **Registro de Usuário:**
   - Usuário preenche um formulário.
   - Recebe um email com um link de ativação.
   - Após ativar, pode realizar login.

2. **Login:**
   - Usuário envia email e senha.
   - Backend retorna JWT e URL de redirecionamento.

3. **OAuth para Aplicações Externas:**
   - Aplicação cliente redireciona o usuário para o IDP.
   - Após autenticação, o usuário é redirecionado de volta para a aplicação com um token.

4. **Recuperação de Senha:**
   - Usuário solicita redefinição informando o email.
   - Recebe link para criar uma nova senha.

---

## O que Será Aprendido

1. **Fundamentos de Autenticação e Segurança:**
   - Hash de senhas com `bcrypt`.
   - Uso de JWTs para autenticação.

2. **Protocolos:**
   - Implementação básica do OAuth 2.0.

3. **Backend Avançado:**
   - Criação de APIs RESTful seguras.
   - Gerenciamento de tokens e sessões.

4. **Integrações:**
   - Envio de emails com provedores externos (SendGrid ou Mailgun).

---

## Publicação

1. **Configuração de Ambiente:**
   - Banco de dados relacional na nuvem (ex.: AWS RDS, Heroku Postgres).
   - Backend em uma plataforma como Heroku, Vercel ou AWS Lambda.

2. **Frontend:**
   - Hospedar as páginas estáticas em serviços como Netlify ou Vercel.

3. **Domínio Customizado (Opcional):**
   - Configurar um domínio próprio para o IDP.

---

## Possibilidades de Expansão

1. **Autenticação Multifator (MFA):**
   - Adicionar autenticação via SMS ou aplicativos como Google Authenticator.

2. **Administração:**
   - Painel para gerenciar usuários e tokens.

3. **Suporte Avançado ao OAuth 2.0:**
   - Permitir que outros sistemas utilizem o IDP para autenticação.

Bom desafio! 🚀


Desafio de programação para criar um autenticador como Provedor de Identidade (IDP), explorando registro, login, segurança com JWT e fluxo OAuth 2.0.

#5 Autenticador



# #4 Desafio de Programação: Sistema de Ponto

## Descrição
Desenvolva um **Sistema de Ponto** para empresas, onde funcionários podem registrar seus horários de entrada e saída, e administradores podem acompanhar e gerenciar esses registros. O foco principal é no backend, mas um frontend simples e opcional pode ser criado para demonstrar o funcionamento básico do sistema.

---

## Objetivo
Criar uma API backend para:
1. Gerenciar usuários (funcionários e administradores).
2. Registrar horários de entrada e saída.
3. Calcular horas trabalhadas.
4. Fornecer relatórios e métricas para administradores.

---

## Requisitos Técnicos
### MVP (Minimum Viable Product)
1. API RESTful com endpoints para registro, consulta e relatório de pontos.
2. Banco de dados estruturado para armazenar registros de ponto, usuários e seus papéis.
3. Cálculo de horas trabalhadas por dia, semana ou mês.
4. Controle de autenticação e autorização:
   - Usuários autenticados podem registrar seus pontos.
   - Administradores têm acesso aos relatórios e métricas.

### Extras para Diferencial
1. Integração com notificações (ex.: lembrete para bater ponto).
2. Painel web para gerenciamento.
3. Relatórios exportáveis (CSV ou PDF).
4. Configuração de horas extras e jornadas específicas.

---

## Fluxo de Uso

### Funcionários
1. Fazem login no sistema.
2. Registram horários de entrada e saída.
3. Consultam o histórico de pontos e horas trabalhadas.

### Administradores
1. Fazem login no sistema com privilégios elevados.
2. Visualizam e gerenciam os registros de todos os funcionários.
3. Geram relatórios com base em filtros (por funcionário, data, etc.).
4. Configuram a jornada padrão (ex.: 8h diárias, 44h semanais).

---

## Endpoints

### Autenticação
1. **Registrar usuário**
   - **POST** `/api/users/register`
   - Body:
     ```json
     {
       "name": "Fulano da Silva",
       "email": "joao@example.com",
       "password": "123456",
       "role": "employee"
     }
     ```
   - Response:
     ```json
     {
       "id": "12345",
       "message": "User created successfully"
     }
     ```

2. **Login**
   - **POST** `/api/auth/login`
   - Body:
     ```json
     {
       "email": "joao@example.com",
       "password": "123456"
     }
     ```
   - Response:
     ```json
     {
       "token": "jwt-token",
       "role": "employee"
     }
     ```

### Funcionários
1. **Registrar ponto**
   - **POST** `/api/punch-clock`
   - Headers: `Authorization: Bearer <jwt-token>`
   - Body:
     ```json
     {
       "type": "check-in" // or "check-out"
     }
     ```
   - Response:
     ```json
     {
       "message": "Ponto registrado com sucesso",
       "timestamp": "2024-11-21T08:00:00Z"
     }
     ```

2. **Consultar histórico de pontos**
   - **GET** `/api/punch-clock/history`
   - Headers: `Authorization: Bearer <jwt-token>`
   - Response:
     ```json
     [
       {
         "date": "2024-11-21",
         "check-in": "08:00",
         "check-out": "17:00",
         "hours_worked": 9
       }
     ]
     ```

### Administradores
1. **Listar todos os registros**
   - **GET** `/api/admin/punch-clock`
   - Headers: `Authorization: Bearer <jwt-token>`
   - Query Params:
     - `employeeId` (opcional)
     - `startDate` e `endDate` (opcional)
   - Response:
     ```json
     [
       {
         "employee": "Fulano da Silva",
         "date": "2024-11-21",
         "check-in": "08:00",
         "check-out": "17:00",
         "hours_worked": 9
       }
     ]
     ```

2. **Gerar relatório**
   - **GET** `/api/admin/reports`
   - Headers: `Authorization: Bearer <jwt-token>`
   - Query Params:
     - `startDate`
     - `endDate`
   - Response (CSV ou JSON):
     ```json
     {
       "total_hours": 44,
       "employees": [
         {
           "name": "Fulano da Silva",
           "hours_worked": 44
         },
         {
           "name": "Ciclana Machado",
           "hours_worked": 40
         }
       ]
     }
     ```

---

## Estrutura do Banco de Dados

### Tabelas

1. **Users**
   - `id` (UUID, Primary Key)
   - `name` (String)
   - `email` (String, único)
   - `password` (Hash)
   - `role` (Enum: `employee`, `admin`)

2. **PunchClock**
   - `id` (UUID, Primary Key)
   - `user_id` (Foreign Key para `Users`)
   - `type` (Enum: `check-in`, `check-out`)
   - `timestamp` (DateTime)

3. **Settings**
   - `id` (UUID, Primary Key)
   - `workday_hours` (Decimal, horas padrão por dia)
   - `overtime_rate` (Decimal, taxa de hora extra)

---

## Tecnologias Recomendadas

### Backend
- Sugestões de Linguagem: .NET Core, Java, Node.js (Express) ou Python (Django/Flask).
- Banco de Dados: PostgreSQL ou MySQL.
- Autenticação: JWT (JSON Web Tokens).

### Frontend (Opcional)
- Framework: React.js, Angular ou Vue.js.
- Design: Tailwind CSS ou Ant Design.

### Extras
- Notificações: Twilio ou SendGrid para lembretes.
- Relatórios: Biblioteca como `pdfkit` ou `xlsx`.

---
## Como Disponibilizar no Portfólio

Para adicionar esse projeto ao seu portfólio de maneira atrativa, considere os seguintes pontos:

1. **Publicar no GitHub com um bom README.md**: Suba o código no GitHub com uma descrição completa do projeto, incluindo uma breve introdução, estrutura do banco de dados, principais endpoints e instruções para instalação modo de uso, regras de negócio, explicação das decisões técnicas e etc.

3. **Documentação da API**: Use o Swagger ou Postman para documentar a API, incluindo exemplos de requisições e respostas. Isso facilita a compreensão das funcionalidades e mostra seu cuidado com documentação.

4. **Demonstração com Docker**: Disponibilize uma configuração Docker para facilitar a execução da API. Isso torna o projeto acessível para quem deseja testá-lo rapidamente.

5. **Apresentação Visual**: Crie um README.md organizado e visualmente atrativo, com imagens e diagramas simples (como diagrama ER) para demonstrar o funcionamento e a arquitetura do sistema.

6. **Demo em Produção**: Se possível, hospede o projeto em uma plataforma gratuita como Vercel ou Render, para que recrutadores ou interessados possam testar a API em tempo real.

7. **Explicação Técnica no Portfólio**: Adicione uma seção explicando os desafios enfrentados e soluções implementadas. Destacar problemas específicos resolvidos mostra seu conhecimento técnico.

---

Boa sorte e bom desafio! 🚀


Desenvolva um Sistema de Ponto completo com foco em backend, permitindo registro de horários, cálculo de horas trabalhadas e geração de relatórios para administradores.

#4 Sistema de Ponto



# #3 Desafio de Programação: Sistema de Fila de Espera

## Objetivo
Desenvolver um **Sistema de Fila de Espera** completo, desde o backend até a interface (opcional), que organiza clientes em filas de atendimento. O sistema deve gerenciar múltiplas filas, priorizar atendimentos, enviar notificações e fornecer painéis para administração e consulta dos clientes.

---

## Especificação do Desafio
Você deverá construir um sistema funcional com as seguintes capacidades:

### Mínimo Viável
1. Registro de clientes em filas com categorias e prioridades.
2. Listagem de clientes na fila com ordenação por prioridade.
3. Chamar clientes em ordem e registrar o histórico.
4. Consulta do cliente à sua posição na fila.

### Extras para Diferencial
1. Notificações por SMS ou e-mail.
2. Painel administrativo com métricas (tempo médio de espera, volume de atendimentos).
3. Configuração de regras de fila e prioridades.

---

## O que será aprendido
- **Backend:**
  - Desenvolvimento de APIs RESTful.
  - Organização de filas e priorização.
  - Persistência de dados com bancos de dados relacionais ou não-relacionais.
- **Frontend (opcional):**
  - Criação de interfaces simples para painéis de clientes e administradores.
  - Consumo de APIs.
- **DevOps:**
  - Autenticação e autorização com JWT.
  - Configuração de um sistema para notificações externas (ex.: Twilio).
- **Conceitos Gerais:**
  - Manipulação de filas.
  - Estruturação e otimização de queries no banco de dados.
  - Design de sistemas escaláveis e de alto desempenho.

---

## Arquitetura

### 1. Diagrama de Arquitetura
```
[Frontend]
    ↓ (API RESTful)
[Backend]
    ↓
[Database]
```

### 2. Camadas
1. **Frontend** (opcional):
   - Painel do cliente para consultar posição na fila.
   - Painel administrativo para gerenciar filas e visualizar métricas.
2. **Backend**:
   - API para registro, listagem, chamada e notificações.
   - Lógica de prioridade e reordenação.
3. **Database**:
   - Relacional: PostgreSQL/MySQL.
   - Estruturas básicas:
     - **Clientes**: ID, nome, prioridade, tipo, status.
     - **Filas**: ID, categoria, clientes em espera.
     - **Histórico**: Data, hora, cliente chamado.

---

## Endpoints

### 1. Endpoints de Cliente
1. **Registrar cliente na fila**
   - **POST** `/api/queue`
   - Body:
     ```json
     {
       "name": "João Silva",
       "category": "Consulta",
       "priority": "Normal",
       "contact": "email@example.com"
     }
     ```
   - Response:
     ```json
     {
       "id": "12345",
       "position": 5
     }
     ```

2. **Consultar posição na fila**
   - **GET** `/api/queue/{id}/position`
   - Response:
     ```json
     {
       "position": 5,
       "estimated_time": "15 minutes"
     }
     ```

3. **Cancelar inscrição na fila**
   - **DELETE** `/api/queue/{id}`

---

### 2. Endpoints Administrativos
1. **Listar todos os clientes na fila**
   - **GET** `/api/queue`
   - Response:
     ```json
     [
       {
         "id": "12345",
         "name": "João Silva",
         "position": 1,
         "priority": "Normal"
       }
     ]
     ```

2. **Chamar próximo cliente**
   - **POST** `/api/queue/next`
   - Response:
     ```json
     {
       "called": {
         "id": "12345",
         "name": "João Silva"
       },
       "position": 1
     }
     ```

3. **Visualizar métricas**
   - **GET** `/api/admin/metrics`
   - Response:
     ```json
     {
       "average_wait_time": "10 minutes",
       "total_attended": 25,
       "categories": {
         "Consulta": 15,
         "Exame": 10
       }
     }
     ```

---

## Estrutura de Dados

### Tabelas Relacionais
1. **Clientes**
   - `id`: ID único.
   - `name`: Nome do cliente.
   - `category`: Tipo de fila.
   - `priority`: Prioridade do cliente.
   - `status`: Em espera, atendido, ou desistente.
2. **Filas**
   - `id`: ID único.
   - `category`: Nome da categoria.
   - `clients`: Lista de IDs de clientes associados.
3. **Histórico**
   - `id`: ID único.
   - `client_id`: ID do cliente atendido.
   - `called_at`: Data e hora da chamada.

---

## Diferenciais (Extras)
- **Notificações Externas**:
  - Integre com serviços como Twilio ou SendGrid para enviar alertas.
- **UX/UI**:
  - Crie uma interface visual intuitiva para gerenciamento.
- **Escalabilidade**:
  - Adicione balanceamento de carga para filas com grande volume de clientes.
- **Automação**:
  - Crie scripts para geração de dados de teste e simulação de filas em tempo real.

---


## Como Disponibilizar no Portfólio

Para adicionar esse projeto ao seu portfólio de maneira atrativa, considere os seguintes pontos:

1. **Publicar no GitHub com um bom README.md**: Suba o código no GitHub com uma descrição completa do projeto, incluindo uma breve introdução, estrutura do banco de dados, principais endpoints e instruções para instalação modo de uso, regras de negócio, explicação das decisões técnicas e etc.

3. **Documentação da API**: Use o Swagger ou Postman para documentar a API, incluindo exemplos de requisições e respostas. Isso facilita a compreensão das funcionalidades e mostra seu cuidado com documentação.

4. **Demonstração com Docker**: Disponibilize uma configuração Docker para facilitar a execução da API. Isso torna o projeto acessível para quem deseja testá-lo rapidamente.

5. **Apresentação Visual**: Crie um README.md organizado e visualmente atrativo, com imagens e diagramas simples (como diagrama ER) para demonstrar o funcionamento e a arquitetura do sistema.

6. **Demo em Produção**: Se possível, hospede o projeto em uma plataforma gratuita como Vercel ou Render, para que recrutadores ou interessados possam testar a API em tempo real.

7. **Explicação Técnica no Portfólio**: Adicione uma seção explicando os desafios enfrentados e soluções implementadas. Destacar problemas específicos resolvidos mostra seu conhecimento técnico.

---


Boa sorte e bom desafio! 🚀


Sistema para gerenciar filas de espera e consultar posições nela.

 #3 Fila de Espera


# #2 Desafio de Programação: Sistema de Notificação 🚀

## 📚 Visão Geral
Desenvolva um Sistema de Notificação eficiente e escalável que gerencie o envio de mensagens para usuários através de múltiplos canais (e-mail, SMS, push notifications). 

O sistema deve utilizar filas de mensagens (RabbitMQ ou Kafka) para processamento assíncrono, suportando a priorização de notificações para garantir que as mensagens mais críticas sejam enviadas primeiro.


## 🎓 Aprendizados Esperados

- **Sistemas de Filas:**
  - Compreensão de conceitos de enfileiramento e processamento assíncrono.
  - Configuração e utilização de RabbitMQ ou Kafka.
- **Priorização de Mensagens:**
  - Implementação prática de priorização em sistemas de mensagens.
  - Gerenciamento de múltiplas filas ou tópicos com diferentes prioridades.
- **Integração com Serviços Externos:**
  - Experiência em trabalhar com APIs de terceiros para envio de notificações.
- **Escalabilidade e Resiliência:**
  - Design de sistemas capazes de lidar com altos volumes de dados e garantir alta disponibilidade.
- **Monitoramento e Manutenção:**
  - Implementação de ferramentas de monitoramento e logging para garantir a saúde do sistema.


## 🏗️ Arquitetura do Sistema
### 📦 Componentes Principais

![Desenho da Arquitetura](/assets/challenges/sistema-de-notificacoes/arch-design.png)


## 🎯 Requisitos Funcionais

1. Envio de Notificações
   - **Canais Suportados:**
     - E-mail
     - SMS
     - Push Notifications
   - **Tipos de Notificações:**
     - Alertas (Alta Prioridade)
     - Confirmações (Média Prioridade)
     - Promoções/Newsletters (Baixa Prioridade)
   - **Personalização:**
     - Utilização de templates com placeholders para dados dinâmicos.
2. Gerenciamento de Mensagens
   - **Enfileiramento:**
     - Mensagens devem ser enfileiradas para processamento assíncrono.
   - **Prioridade:**
     - Níveis de prioridade (Alta, Média, Baixa).
     - Processamento das mensagens de acordo com a prioridade. 
3. API de Integração
   - **Endpoints RESTful:**
     - `POST /notifications` – Criação de notificações.
     - `GET /notifications/{id}` – Consulta de status de uma notificação.
   - **Parâmetros da Requisição:**
     - `channel` (e-mail, SMS, push)
     - `recipient` (endereço de e-mail, número de telefone, device token)
     - `message` (conteúdo ou referência ao template)
     - `priority` (alta, média, baixa)
     - `data` (dados adicionais para templates)
   - **Autenticação:**
     - Tokens de API ou JWT.
4. Autenticação e Segurança
   - **Controle de Acesso:**
     - Apenas clientes autenticados podem utilizar a API.
   - **Validação de Dados:**
     - Verificação de campos obrigatórios e formatos (e-mail, telefone).
   - **Criptografia:**
     - Comunicação via HTTPS.
     - Criptografia de dados sensíveis em repouso.
5. Reenvio Automático e Dead Letter Queue
   - **Reintentos Automáticos:**
     - Número configurável de tentativas em caso de falha.
     - Intervalo ajustável entre tentativas.
   - **Dead Letter Queue:**
     - Armazenamento de mensagens que falharam após todas as tentativas.
6. Registro e Monitoramento
   - **Logs de Atividade:**
     - Registro de todas as notificações enviadas, status e erros.
   - **Monitoramento Básico:**
     - Logs acessíveis para análise e troubleshooting.

## 🔧 Detalhes Técnicos
1. API Gateway
   - **Responsabilidades:**
     - Receber e autenticar requisições dos clientes.
     - Validar os dados recebidos.
     - Enviar mensagens para o sistema de filas com a prioridade adequada.
   - **Endpoints Principais:**
     - `POST /notifications`
     - `GET /notifications/{id}`
2. Sistema de Filas (RabbitMQ/Kafka)
   - **RabbitMQ:**
     - **Exchanges e Filas:**
       - Configuração de exchanges diretas ou de tópicos para roteamento.
       - Filas configuradas com suporte a prioridade (x-max-priority).
     - **Priorização:**
       - Mensagens enviadas com atributo priority (1-10).
   - **Kafka:**
     - Tópicos:
       - Tópicos separados para cada nível de prioridade (e.g., `high`, `medium`, `low`).
     - Consumo:
       - Workers configurados para consumir tópicos em ordem de prioridade.
3. Workers Consumidores
   - **Funções:**
     - Consumir mensagens das filas.
     - Enviar notificações através dos canais apropriados.
     - Gerenciar reintentos e mover mensagens para Dead Letter Queue em caso de falha.
   - **Escalabilidade:**
     - Implementar múltiplas instâncias de workers para lidar com alta demanda.
4. Serviços de Notificação Externos
   - **E-mail:** Integrar com SendGrid, Mailgun ou Amazon SES via APIs.
   - **SMS:** Utilizar Twilio ou Nexmo para envio de mensagens de texto.
   - **Push Notifications:** Integrar com Firebase Cloud Messaging ou Apple Push Notification Service.
5. Banco de Dados
   - **Finalidades:**
     - Armazenar logs de notificações enviadas.
     - Registrar o status, tentativas e erros das notificações.
     - Armazenar templates de mensagens e configurações.
6. Registro e Monitoramento
   - **Logs de Atividade:**
     - Implementar logging interno para registrar todas as operações.
     -  Utilizar bibliotecas como Winston (Node.js) ou Logging (Python) para gerenciamento de logs.
   - **Monitoramento Básico:**
     - Monitorar logs para identificar falhas e comportamentos anômalos.

## 📈 Fluxos de Trabalho
1. **Envio de Notificação**
    1. **Cliente** envia uma requisição `POST /notifications` com os detalhes da notificação.
    2. **API Gateway** autentica e valida a requisição.
    3. **Mensagem** é enfileirada no sistema de filas com a prioridade especificada.
    4. **Workers** consomem a mensagem e enviam a notificação através do canal adequado.
    5. **Status** da notificação é atualizado no banco de dados.
    6. **Logs** são registrados para monitoramento e auditoria.
2. **Reenvio Automático**
    1. **Falha** no envio da notificação.
    2. **Worker** reenvia a mensagem conforme a política de reintento.
    3. **Após exceder tentativas**, a mensagem é movida para a Dead Letter Queue.
    4. **Administradores** podem revisar e reprocessar mensagens na Dead Letter Queue.
3. **Consulta de Status**
    1. **Cliente** realiza uma requisição `GET /notifications/{id}`.
    2. **API Gateway** busca o status da notificação no banco de dados.
    3. **Resposta** com o status atual (enviado, pendente, falhado).

## 📋 Regras de Negócio

- **Prioridade de Mensagens:**
  - **Alta:** Alertas críticos (e.g., falhas de segurança) – devem ser processados imediatamente.
  - **Média:** Confirmações e atualizações de status – processadas após alta prioridade.
  - **Baixa:** Promoções e newsletters – processadas quando não há mensagens de alta ou média prioridade.
- **Tentativas:**
  - **Configuração:**
    - Máximo de 3 tentativas.
    - Intervalo de 5 minutos entre tentativas.
  - **Dead Letter Queue:**
    - Mensagens que falham após todas as tentativas são armazenadas para análise.
  - **Autenticação e Segurança:**
    - Uso de HTTPS para todas as comunicações.
    - Autenticação via JWT ou chaves de API.
    - Limitação de taxa (Rate Limiting) para prevenir abusos.
- **Validação de Dados:**
  - Formatos corretos para e-mail, número de telefone e tokens de push.
  - Campos obrigatórios devem ser preenchidos.

## 🌟 Funcionalidades Adicionais (Expansão Futuramente)
- **Autenticação Multifator (MFA):**
  - Adicionar um segundo fator de autenticação para clientes que acessam a API.
- **Interface de Administração:**
  - Dashboard para gerenciar notificações, visualizar logs e monitorar desempenho.
- **Análise de Dados:**
  - Relatórios sobre taxas de entrega, abertura de e-mails, cliques em links, etc.
- **Suporte a Novos Canais:**
  - Adicionar suporte a WhatsApp, Telegram ou notificações in-app.
- **Escalabilidade Avançada:**
  - Implementar Kubernetes para orquestração de containers e escalabilidade automática.

### 🏁 Como Participar do Desafio

- **Planejamento:**
  - Revise os requisitos e entenda o fluxo do sistema.
  - Escolha as tecnologias que você está mais confortável ou deseja aprender.
- **Implementação:**
  - Configure o ambiente de desenvolvimento.
  - Desenvolva a API e integre com o sistema de filas escolhido.
  - Implemente os workers para processar e enviar notificações.
- **Testes:**
  - Teste cada canal de notificação.
  - Verifique a priorização e o reenvio automático de mensagens.
  - Assegure-se de que a segurança e a autenticação estão funcionando corretamente.
- **Documentação:**
  - Documente o código e crie um README detalhado.
  - Inclua instruções de configuração e execução do sistema.
- **Compartilhe:**
  - Publique seu projeto no GitHub.
  - Compartilhe no Instagram ou outras redes sociais utilizando a hashtag do desafio.

## 🏆 Pronto para o Desafio?

Boa sorte e mãos à obra! 🚀


#2 Sistema de Notificações



# #1 Desafio de Programação: Desafio: Sistema de Reservas de Restaurante

Neste desafio, você vai construir uma API para gerenciar reservas de mesas em um restaurante. O objetivo é desenvolver funcionalidades comuns em sistemas reais de reserva, incluindo autenticação, validação e controle de disponibilidade. Esse projeto será uma ótima adição ao seu portfólio de backend!

## Requisitos do Projeto

### Objetivo Principal
Desenvolver uma API RESTful para:
- Registrar reservas de mesas.
- Controlar o status das reservas e das mesas.
- Bloquear reservas quando a mesa estiver ocupada.

### Stack Recomendado
- **Backend**: Node.js (Express), .NET Core ou Java (Spring).
- **Banco de Dados**: MySQL ou PostgreSQL
- **Autenticação**: JWT (JSON Web Tokens)

---

## Funcionalidades

1. **Autenticação de Usuário**
   - **Registro**: O usuário deve ser capaz de se registrar com um nome, e-mail e senha.
   - **Login**: Usuários autenticados recebem um token JWT para acesso às funcionalidades de reservas.
   - **Restrição de Acesso**: Apenas usuários logados podem criar e visualizar reservas.

2. **Gestão de Mesas**
   - **Listagem**: Listar todas as mesas disponíveis no restaurante.
   - **Criar Mesa**: Administradores podem adicionar novas mesas ao sistema com um nome e capacidade de pessoas.
   - **Status da Mesa**: Cada mesa pode estar `disponível`, `reservada` ou `inativa`.

3. **Sistema de Reservas**
   - **Criar Reserva**: Usuários autenticados podem criar reservas para mesas específicas.
   - **Verificar Disponibilidade**: A API deve verificar se a mesa está disponível no horário solicitado antes de confirmar a reserva.
   - **Cancelar Reserva**: Usuários podem cancelar suas reservas, o que libera a mesa para novas reservas.

4. **Controle de Status**
   - **Status das Mesas**: Mesas ficam `reservadas` automaticamente ao serem associadas a uma reserva.
   - **Status das Reservas**: Reservas têm status `ativo` quando confirmadas e `cancelado` quando canceladas.

---

## Estrutura do Banco de Dados

- **Usuários**
    - `id`: Identificador único.
    - `nome`: Nome do usuário.
    - `email`: E-mail do usuário (único).
    - `senha`: Senha do usuário, armazenada com hash.
    - `role`: Papel do usuário (ex.: `cliente` ou `administrador`).

- **Mesas**
    - `id`: Identificador único.
    - `nome`: Nome ou número da mesa.
    - `capacidade`: Quantidade máxima de pessoas que a mesa comporta.
    - `status`: Status atual da mesa (`disponível`, `reservada`, `inativa`).

- **Reservas**
    - `id`: Identificador único.
    - `usuario_id`: ID do usuário que fez a reserva.
    - `mesa_id`: ID da mesa reservada.
    - `data_reserva`: Data e horário da reserva.
    - `status`: Status da reserva (`ativo`, `cancelado`).

---

## Endpoints da API

### Autenticação
- `POST /usuarios/registrar` — Cadastro de novos usuários.
- `POST /usuarios/login` — Login de usuários e geração de token JWT.

### Mesas
- `GET /mesas` — Lista todas as mesas e seus status.
- `POST /mesas` — Adiciona uma nova mesa (apenas administradores).
- `PATCH /mesas/:id` — Atualiza informações de uma mesa.
- `DELETE /mesas/:id` — Remove uma mesa (apenas administradores).

### Reservas
- `POST /reservas` — Cria uma nova reserva, validando disponibilidade e a capacidade da mesa.
- `GET /reservas` — Lista todas as reservas do usuário autenticado.
- `PATCH /reservas/:id/cancelar` — Cancela uma reserva ativa.

---

## Regras de Negócio

1. **Verificação de Disponibilidade**
   - Antes de criar uma reserva, verifique se a mesa está disponível no horário desejado.

2. **Validação de Capacidade**
   - O sistema deve validar a capacidade da mesa para atender o número de pessoas indicado na reserva.

3. **Cancelamento de Reserva**
   - Quando uma reserva é cancelada, o sistema deve atualizar o status da mesa para `disponível`.

4. **Permissões de Usuário**
   - Apenas administradores podem adicionar, atualizar ou remover mesas.
   - Apenas o usuário que criou uma reserva pode cancelá-la.

---

## Validação de Dados

- **Datas e Horários**: A reserva só pode ser feita para horários futuros dentro do horário de funcionamento do restaurante.
- **Campos Obrigatórios**: Valide a presença de todos os campos obrigatórios em cada endpoint.
- **Formatos**: E-mails e datas devem estar em formatos corretos.

---

## O Que Você Pode Aprender Com Isso

Esse projeto cobre habilidades importantes para o desenvolvimento backend e simula situações reais de um sistema de reservas. Ao implementá-lo, você poderá aprender:

1. **CRUD Completo**: Como construir e organizar uma API com operações básicas (criação, leitura, atualização e exclusão) para recursos, como usuários, mesas e reservas.
2. **Autenticação e Autorização**: Uso de JWT para proteger rotas e controlar permissões de usuários.
3. **Validação de Dados**: Como validar entradas para garantir a integridade das informações, como horário, capacidade e status.
4. **Controle de Disponibilidade**: Gerenciamento de reservas e status para impedir duplicidade de reservas no mesmo horário e mesa.
5. **Modelagem de Banco de Dados**: Estruturar um banco relacional para representar relacionamentos e garantir consistência entre as entidades.
6. **Boas Práticas de API REST**: Aprender padrões e organização de rotas e respostas HTTP para melhorar a qualidade do código e documentação.

---

## Como Disponibilizar no Portfólio

Para adicionar esse projeto ao seu portfólio de maneira atrativa, considere os seguintes pontos:

1. **Publicar no GitHub com um bom README.md**: Suba o código no GitHub com uma descrição completa do projeto, incluindo uma breve introdução, estrutura do banco de dados, principais endpoints e instruções para instalação modo de uso, regras de negócio, explicação das decisões técnicas e etc.

3. **Documentação da API**: Use o Swagger ou Postman para documentar a API, incluindo exemplos de requisições e respostas. Isso facilita a compreensão das funcionalidades e mostra seu cuidado com documentação.

4. **Demonstração com Docker**: Disponibilize uma configuração Docker para facilitar a execução da API. Isso torna o projeto acessível para quem deseja testá-lo rapidamente.

5. **Apresentação Visual**: Crie um README.md organizado e visualmente atrativo, com imagens e diagramas simples (como diagrama ER) para demonstrar o funcionamento e a arquitetura do sistema.

6. **Demo em Produção**: Se possível, hospede o projeto em uma plataforma gratuita como Vercel ou Render, para que recrutadores ou interessados possam testar a API em tempo real.

7. **Explicação Técnica no Portfólio**: Adicione uma seção explicando os desafios enfrentados e soluções implementadas. Destacar problemas específicos resolvidos mostra seu conhecimento técnico.

---

Esse desafio prático permite que você aprenda e aplique habilidades essenciais para backend enquanto cria algo útil para seu portfólio. Boa sorte e mãos à obra!


Desafios