# BUSINESS_FLOWS_ANALYSIS.md

## 1. Principais módulos do sistema (com base na estrutura encontrada)
1. Páginas de conteúdo (PHP templates/render):
   - `index.php` (Home/landing)
   - `quemsomos.php`
   - `hospedagem.php`
   - `card.php` (Planos)
   - `email.php`
   - `tutorial.php` (Tutoriais)
   - `registro.php`
   - `wordpress.php`
   - `contato.php` (Contato)
   - `span.php` (Política anti-spam)
   - `duvidas.php`
2. Composição de layout (partials reutilizáveis):
   - `includes/header.php` (HTML head + metadados + canonical/OG/schema + includes de dependências via CDN)
   - `includes/nav.php` (menu desktop/mobile + JS inline)
   - `includes/footer.php` (rodapé + WhatsApp flutuante)
3. Frontend “comportamental” (scripts inline):
   - JS em `includes/nav.php` (toggle do menu mobile)
   - JS em `tutorial.php` (expand/collapse de artigos)
   - JS em `index.php` (fade/opacidade de imagens conforme scroll)

Não há módulos de domínio (ex.: `services/`, `repositories/`, `models/`) ou camadas de persistência.

## 2. Principais fluxos de negócio
Como não há persistência nem APIs, os “fluxos” são essencialmente navegação/engajamento no site:
1. Navegar entre páginas (Home, Quem Somos, E-mail, Hospedagem, Planos etc.)
2. Expandir tutoriais no `tutorial.php`
3. Acionar contato via:
   - WhatsApp (botões “Assinar” e botão flutuante)
   - E-mail (`mailto:`)
   - Página de contato (`contato.php`) com atalho para WhatsApp, e-mail e Central do Cliente
4. Redirecionar para “Central do Cliente” (link externo em `nav.php`)
5. Linkar para “Registro.br” (link externo em `registro.php`)

## 3. Endpoints e APIs
### Endpoints internos
- Não há endpoints REST/SOAP/GraphQL.
- Cada página é acessada diretamente como rota de arquivo PHP via servidor web:
  - `GET /index.php`
  - `GET /quemsomos.php`
  - `GET /hospedagem.php`
  - `GET /card.php`
  - `GET /email.php`
  - `GET /tutorial.php`
  - `GET /registro.php`
  - `GET /wordpress.php`
  - `GET /contato.php`
  - `GET /span.php`
  - `GET /duvidas.php`

### Evidências de “ausência de APIs/back-end transacional”
- Não foram encontrados no código quaisquer usos de:
  - `$_POST`, `$_GET`, `$_REQUEST`, `$_COOKIE`
  - `PDO`, `mysqli`, `mysql_*`
  - `curl`/`file_get_contents`/sockets
  - `mail(` e bibliotecas como `PHPMailer`/`SwiftMailer`
  - tags `<form>` e atributos `action=`

Ou seja: não existe backend para “Cadastro”, “Autenticação”, “Envio de formulário”, “Persistência” etc.

## 4. Entidades e modelos de banco
- Nenhuma entidade/modelo de banco foi identificada.
- Não há conexão com banco (nem `PDO`, nem `mysqli`, nem queries SQL).
- Portanto, **não existe esquema relacional ou modelos** no projeto atual.

## 5. Integrações externas
1. Tailwind CSS via CDN: `https://cdn.tailwindcss.com`
2. Font Awesome via CDN: `https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.5.1/css/all.min.css`
3. Google Fonts (Inter): `https://fonts.googleapis.com/css2?family=Inter:...`
4. WhatsApp:
   - Botão flutuante: `https://wa.me/5547996498116`
   - Botões “Assinar” (planos): `https://api.whatsapp.com/send?phone=...&text=...`
5. E-mail: `mailto:suporte@42net.com.br` (e outros `mailto:`)
6. Central do Cliente (cPanel) via link externo: `https://id.cpanel.net/get/login?...`
7. Google Maps (link externo no texto/rodapé de conteúdo do Home)
8. Registro.br: `https://registro.br`
9. Conteúdo externo em `wordpress.php`:
   - Imagem do logo WordPress via Wikimedia (`https://upload.wikimedia.org/...`)

## 6. Fluxos importantes detalhados (Frontend → Endpoint → Service → Banco)

### Fluxo A: Navegar entre páginas (site)
Frontend (web/mobile) -> clicar em links do menu/hero/CTAs -> Endpoint -> `GET /{pagina}.php` -> Service -> renderização de template (via includes) -> Banco -> N/A

Mapeamento de páginas (exemplos):
- Home: `GET /index.php`
- Planos: `GET /card.php`
- Tutoriais: `GET /tutorial.php`
- E-mail corporativo: `GET /email.php`
- Hospedagem: `GET /hospedagem.php`
- Quem Somos: `GET /quemsomos.php`
- Registro de Domínios: `GET /registro.php`
- Hospedagem WordPress: `GET /wordpress.php`
- Política anti-spam: `GET /span.php`
- Dúvidas frequentes: `GET /duvidas.php`

Service (no sentido de “lógica”):
- Não existe service layer; o “serviço” é o próprio PHP que:
  - define `$pageTitle` e `$pageDescription`,
  - faz `include` de `includes/header.php`,
  - inclui `includes/nav.php`,
  - entrega o HTML da página,
  - fecha com `includes/footer.php`.

Banco:
- Não há conexão.

### Fluxo B: Expandir artigos no `tutorial.php`
Frontend -> clique no botão `.toggle-article` -> Endpoint -> nenhum endpoint (apenas JS altera DOM) -> Service -> N/A (lógica no browser) -> Banco -> N/A

Base no código:
- `tutorial.php` adiciona listener para `.toggle-article` e alterna classe `.hidden` em `.article-details`.

### Fluxo C: Contato via WhatsApp (botões de planos e botão flutuante)
Frontend -> clique em “Assinar” (planos) ou botão flutuante -> Endpoint -> URL externa `https://api.whatsapp.com/...` ou `https://wa.me/...` -> Service -> N/A (fora do projeto) -> Banco -> N/A

Observação:
- Não há coleta de dados no backend deste projeto; a ação dispara o link externo diretamente.

### Fluxo D: Contato via e-mail (mailto)
Frontend -> clique em link `mailto:` -> Endpoint -> `mailto:suporte@42net.com.br` (abre cliente de e-mail do usuário) -> Service -> N/A -> Banco -> N/A

### Fluxo E: Acessar Central do Cliente (cPanel login)
Frontend -> clique em “Central do Cliente” no menu -> Endpoint -> URL externa `https://id.cpanel.net/get/login?...` -> Service -> N/A -> Banco -> N/A

### Fluxo F: Redirecionar para Registro.br
Frontend -> clique em `Registro.br` -> Endpoint -> `https://registro.br` -> Service -> N/A -> Banco -> N/A

## 7. Possíveis problemas (e onde aparecem no desenho atual)
1. Código duplicado
   - O conteúdo e CTAs por planos aparecem diretamente em `card.php` (sem abstração de componentes).
   - Scripts inline e lógica de UI estão “espalhados” por páginas/partials (`index.php`, `tutorial.php`, `includes/nav.php`).
   - Não há fatorização em componentes reutilizáveis (ex.: “Plano”, “CTA”, “Seção”).

2. Regras de negócio espalhadas
   - Não há regras de negócio complexas (não existe backend).
   - Ainda assim, regras de UI/comportamento (selectors CSS e IDs) ficam embutidas no markup e JS inline, o que cria “regras de apresentação” espalhadas.

3. Falta de tratamento de erro
   - No backend: não há rotas que processem input do usuário, então não há tratamento de erro aplicável (mas também não existe validação/enviar formulários).
   - No frontend: scripts assumem presença de elementos (checam algumas variáveis, como `if (!section1 || !section2 || !img1 || !img2) return;` e `if (!toggle || !menu) return;`), o que reduz falhas.

4. Ausência de testes
   - Não existe infraestrutura de testes (sem `composer.json`, sem `package.json`, sem `phpunit`, sem testes de frontend).

5. Dependências “sem controle local”
   - Tailwind e FontAwesome vêm via CDN, sem versionamento controlado por lockfile/referência local.
   - Isso reduz reprodutibilidade em ambientes offline e dificulta auditoria/atualizações sincronizadas.

6. Possível problema estrutural: acoplamento ao markup
   - O JS depende de IDs/classes (`#mobile-menu-toggle`, `.toggle-article`, `.article-details`).
   - Mudanças no HTML podem quebrar comportamentos sem indicar falhas em tempo de build/test.