Metadata-Version: 2.4
Name: django-webapp-wizard
Version: 0.2.2
Summary: CLI que automatiza a criação de um webapp Django completo: projeto, apps, models com campos, CRUD pronto e banco de dados sempre em dia.
Author-email: Bruno Teixeira <brunomelloteixeira@gmail.com>
License-Expression: MIT
Project-URL: Repository, https://gitlab.ecoa.puc-rio.br/brunoteixeira/djangowizard
Classifier: Environment :: Console
Classifier: Framework :: Django
Classifier: Intended Audience :: Developers
Classifier: Programming Language :: Python :: 3
Classifier: Topic :: Software Development :: Code Generators
Requires-Python: >=3.9
Description-Content-Type: text/markdown
License-File: LICENSE
Provides-Extra: dev
Requires-Dist: pytest>=8; extra == "dev"
Dynamic: license-file

# Django WebApp Wizard

CLI que automatiza a criação de um webapp Django: projeto, apps, models com campos,
telas de CRUD prontas (listar/criar/editar/excluir) com um visual decente, banco de
dados e servidor — tudo com poucos comandos, sem precisar editar código Python.

**Versão:** 0.2.2
**Python:** ≥ 3.9
**PyPI:** https://pypi.org/project/django-webapp-wizard/
**Repositório:** https://gitlab.ecoa.puc-rio.br/brunoteixeira/djangowizard

---

## Instalação

```bash
pip install django-webapp-wizard
```

Para mexer no código do próprio projeto em vez de só usá-lo, instale a partir do
repositório clonado em modo editável:

```bash
pip install -e /caminho/para/djangoWizard
```

Depois disso, o comando `django-wizard` fica disponível no terminal:

```bash
django-wizard --help
```

Não é preciso ter o Django instalado antes — o `django-wizard` cuida disso para
cada projeto, num ambiente isolado (`.venv`) dentro da própria pasta do projeto, para
não conflitar com o Python do seu sistema.

---

## Seu primeiro site em 5 comandos

```bash
# 1. Cria o projeto (instala o Django sozinho, num ambiente isolado)
django-wizard create-project meusite

# 2. Entra na pasta criada
cd meusite

# 3. Cria um app (uma "área" do site, ex.: blog, loja, agenda)
django-wizard create-app blog

# 4. Cria um model com campos e já gera as telas de listar/criar/editar/excluir
django-wizard create-model Post blog titulo:texto conteudo:texto_longo publicado:sim_nao --com-crud

# 5. Liga o site (atualiza o banco, oferece criar um usuário admin, abre o navegador)
django-wizard run
```

Depois do passo 5, seu navegador abre automaticamente em `http://127.0.0.1:8000/`, e
`http://127.0.0.1:8000/blog/post/` já mostra uma lista funcional de "Post" com botões
de criar, editar e excluir — sem uma linha de HTML ou Python escrita à mão.

<details>
<summary>Saída real dos comandos 3 e 4 (para você saber o que esperar)</summary>

```
$ django-wizard create-app blog
[ok] App 'blog' criado em /caminho/meusite/blog
[ok] 'blog' adicionado a INSTALLED_APPS em /caminho/meusite/meusite/settings.py

$ django-wizard create-model Post blog titulo:texto conteudo:texto_longo publicado:sim_nao --com-crud
[ok] Model 'Post' criado no app 'blog'
     - /caminho/meusite/blog/models.py
     - /caminho/meusite/blog/admin.py
[ok] Preparando a alteração no banco de dados...
[ok] Banco de dados atualizado — tabela para 'Post' pronta
[ok] Configuração de arquivos estáticos verificada em /caminho/meusite/meusite/settings.py
     - INSTALLED_APPS: 'django.contrib.staticfiles' já presente
     - STATIC_URL = 'static/' já presente
     - STATICFILES_DIRS = [BASE_DIR / 'static'] adicionado
     - pasta /caminho/meusite/static criada
     Com DEBUG=True, o Django já serve /static/ automaticamente (não é preciso mexer no urls.py).
[ok] CRUD de 'Post' criado no app 'blog'
     - /caminho/meusite/blog/forms.py
     - /caminho/meusite/blog/views.py
     - /caminho/meusite/blog/templates/blog/ (post_list.html, _form.html, _confirm_delete.html, _detail.html)
     - /caminho/meusite/blog/urls.py
     - /caminho/meusite/meusite/urls.py (include de 'blog.urls' adicionado)
     Depois de rodar 'django-wizard run', acesse: /blog/post/
```
</details>

---

## Tipos de campo

Ao criar um model, cada campo é escrito como `nome:tipo`:

```bash
django-wizard create-model Produto loja nome:texto preco:decimal estoque:inteiro ativo:sim_nao categoria:relacao=Categoria
```

| Tipo | O que guarda |
|---|---|
| `texto` | Um texto curto (até 255 caracteres) |
| `texto_longo` | Um texto sem limite de tamanho (parágrafos) |
| `inteiro` | Um número inteiro |
| `decimal` | Um número com casas decimais (preços, medidas) |
| `data` | Uma data |
| `data_hora` | Uma data com horário |
| `sim_nao` | Verdadeiro/falso (uma caixinha de marcar) |
| `email` | Um e-mail |
| `link` | Um endereço da internet (URL) |
| `relacao=NomeDoModel` | Uma ligação com outro model já criado (ex.: `categoria:relacao=Categoria`) |

Sem nenhum campo (`django-wizard create-model Post blog`), o model criado tem só um
campo de texto chamado `name` — útil para protótipos rápidos.

---

## Referência de comandos

### `create-project <nome>`

Cria um ambiente isolado (`.venv`), instala o Django nele e roda a estrutura inicial
do projeto.

```
django-wizard create-project meusite [--django-version 4.2.11]
```

### `create-app <nome>`

Cria uma "área" do site (ex.: `blog`, `loja`) e registra em `INSTALLED_APPS`.

```
django-wizard create-app blog
```

### `create-model <Model> <app> [campos...]`

Cria um model com os campos informados (veja a tabela de tipos acima), registra no
admin e roda `makemigrations`/`migrate` automaticamente.

```
django-wizard create-model Produto loja nome:texto preco:decimal
django-wizard create-model Produto loja nome:texto preco:decimal --com-crud   # já gera o CRUD junto
django-wizard create-model Produto loja nome:texto preco:decimal --sem-migrar # não mexe no banco agora
```

### `create-crud <Model> <app>`

Gera as telas de listar/criar/editar/excluir para um model que já existe (útil se
você não usou `--com-crud` na hora de criar o model). Na primeira vez que é usado num
projeto, também cria um `templates/base.html` e um `static/css/style.css`
compartilhados, para que as telas geradas tenham uma aparência decente.

```
django-wizard create-crud Produto loja
```

### `create-view <view> <app>`

Cria uma view simples (função), um template em branco e as rotas correspondentes.
Mais básico que `create-crud` — útil para uma página avulsa (ex.: uma página "Sobre").

```
django-wizard create-view sobre blog
```

### `run`

O comando para ligar o site: atualiza o banco de dados (`makemigrations`/`migrate`),
oferece criar um usuário administrador se ainda não existir um, sobe o servidor e
abre o navegador.

```
django-wizard run [--port 8000] [--no-browser]
```

### `setup-static`

Configura o projeto para servir arquivos estáticos (CSS/JS/imagens). É chamado
automaticamente por `create-crud`; use-o direto só se quiser essa configuração sem
gerar um CRUD.

```
django-wizard setup-static
```

### Opção global: `--project-dir`

Todo comando aceita `--project-dir <caminho>` (antes ou depois do subcomando) para
apontar para um projeto que não é o diretório atual:

```bash
django-wizard --project-dir ~/projetos/meusite create-app blog
django-wizard create-app blog --project-dir ~/projetos/meusite
```

Padrão: diretório atual (`.`).

---

## Como funciona por baixo dos panos

- **Ambiente isolado:** cada projeto criado por `create-project` ganha seu próprio
  `.venv`. Todo comando seguinte (`create-app`, `run`, etc.) usa esse ambiente
  automaticamente — você nunca precisa ativar um virtualenv manualmente.
- **Banco de dados sempre em dia:** `create-model` e `run` rodam
  `makemigrations`/`migrate` por você. Os tipos de campo têm valores padrão definidos
  de propósito, para que isso nunca pare pedindo uma resposta no meio do processo.
- **Nada fica pela metade:** se algo falhar no meio de um comando (ex.: disco cheio),
  os arquivos já escritos são restaurados ao estado anterior — o projeto nunca fica
  com metade de uma view criada.
- **Seu conteúdo nunca é apagado:** um template que você já editou não é sobrescrito
  se você rodar `create-view` de novo com o mesmo nome.

---

## Solução de problemas

As mensagens de erro do django-wizard (`[erro] ...`) já vêm traduzidas para
português; algumas das mais comuns:

- **"Não foi possível instalar 'django' porque este Python é gerenciado pelo
  sistema..."** — normalmente não deveria mais acontecer, já que cada projeto usa seu
  próprio `.venv`; se aparecer, confirme que está usando a versão mais recente do
  django-wizard.
- **"manage.py não encontrado em ..."** — o comando precisa ser rodado dentro da
  pasta do projeto (a que tem o `manage.py`), ou você precisa passar
  `--project-dir /caminho/do/projeto`.
- **"O model '...' não existe no app '...'"** (`create-crud`) — crie o model primeiro
  com `create-model`, ou confira o nome exato (a mensagem de erro lista os models
  disponíveis nesse app).
- **Erro inesperado sem explicação clara** — rode o mesmo comando de novo com
  `--debug` no final para ver o traceback completo, e inclua isso ao reportar o
  problema.

---

## O que ainda fica por sua conta

O django-wizard gera a estrutura e o CRUD básico, mas não substitui aprender Django
para ir além disso:

- **Autenticação de usuários finais** (login/cadastro do público do site) não é
  gerada — só a criação de um usuário administrador via `run`.
- **Deploy** (colocar o site no ar na internet) não é automatizado por enquanto.
- **Upload de imagens/arquivos** ainda não tem um tipo de campo dedicado.
- Os campos gerados usam valores padrão sensatos, mas você pode querer ajustar
  detalhes (validações, textos de ajuda) direto no `models.py`/`forms.py` gerado —
  são arquivos Python comuns, sem mágica.

---

## Para quem for mexer no código do django-wizard

```bash
python3 -m venv .venv
.venv/bin/pip install -e ".[dev]"

# testes rápidos (não instalam Django de verdade)
.venv/bin/pytest

# testes de ponta a ponta (mais lentos, precisam de internet)
.venv/bin/pytest -m e2e
```

---

## Licença

MIT — veja o arquivo [LICENSE](LICENSE). Use livremente em seus projetos Django.
