Movendo da Interface CLI para Interface Web Completa e Roteamento FastAPI

requirements.txt

@@ -1,3 +1,12 @@
+# Tests
 pytest
 pytest-cov
+
+# lint
 ruff
+
+# Front-end
+fastapi[standard]
+jinja2 
+python-multipart 
+httpx2

src/__init__.py

@@ -1,3 +1,5 @@
+from src.routers import australia_router, auth_router, botc_router, caco_router
+
 from .australia import EleicaoAustralia
 from .botc import SistemaEleitoralBotC
 from .caco import EleicaoAssembleia
@@ -7,5 +9,9 @@
     "EleicaoAssembleia",
     "EleicaoAustralia",
     "SistemaEleitoral",
-    "SistemaEleitoralBotC"
+    "SistemaEleitoralBotC",
+    "australia_router",
+    "auth_router",
+    "botc_router",
+    "caco_router"
 ]

src/main.py

@@ -0,0 +1,68 @@
+from pathlib import Path
+
+from fastapi import FastAPI, Request
+from fastapi.responses import RedirectResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+
+from src.australia import EleicaoAustralia
+from src.autenticacao.australia import EleitorAustralia
+from src.autenticacao.base import ServicoAutenticacao
+from src.autenticacao.botc import JogadorBOTC
+from src.autenticacao.caco import GestaoCACo
+from src.botc import SistemaEleitoralBotC
+from src.caco import EleicaoAssembleia
+from src.routers import australia_router, auth_router, botc_router, caco_router
+from src.routers.dependencias import RequerRedirecionamentoException
+
+app = FastAPI(title="Sistema de Votação Web")
+
+@app.exception_handler(RequerRedirecionamentoException)
+async def auth_exception_handler(request: Request, exc: RequerRedirecionamentoException):
+    return RedirectResponse(url="/", status_code=302)
+
+# Pega o diretório absoluto onde o main.py está (a pasta src/)
+BASE_DIR = Path(__file__).resolve().parent
+
+# Configuração do Frontend com caminhos absolutos
+app.mount("/static", StaticFiles(directory=str(BASE_DIR / "static")), name="static")
+templates = Jinja2Templates(directory=str(BASE_DIR / "templates"))
+
+# --- INICIALIZAÇÃO DO BANCO EM MEMÓRIA ---
+banco_auth = ServicoAutenticacao()
+# Usuários pré-cadastrados para teste <- Talvez seja melhor mudar depois
+banco_auth.registrar(EleitorAustralia("caio", "senha123", "Caio Lima"))
+banco_auth.registrar(GestaoCACo("julia", "admin", "Julia Nardo"))
+banco_auth.registrar(JogadorBOTC("leo", "botc123", "Leonardo Carvalho"))
+
+# Injeta o banco nas rotas
+app.state.banco_auth = banco_auth
+
+
+# Inicialização das eleições
+# Cria a eleição da Austrália com os candidatos
+CANDIDATOS_AUSTRALIA = ["Candidato A", "Candidato B", "Candidato C"]
+eleicao_australia = EleicaoAustralia(candidatos_ids=CANDIDATOS_AUSTRALIA, cedulas=[])
+app.state.eleicao_australia = eleicao_australia
+
+# Cria a assembleia do CACo
+alunos_caco = [banco_auth._mapa_usernames["julia"]] # IDs dos alunos habilitados
+eleicao_caco = EleicaoAssembleia(alunos_cadastrados_ids=alunos_caco, eleitores_ids=alunos_caco, duracao_ciclo=60)
+app.state.eleicao_caco = eleicao_caco
+app.state.eleitores_australia_votaram = set()
+app.state.eleitores_caco_votaram = set()
+
+# Cria a partida do BoTC
+sistema_botc = SistemaEleitoralBotC(jogadores_vivos=10)
+app.state.sistema_botc = sistema_botc
+
+# Registro dos controladores
+app.include_router(auth_router.router)
+app.include_router(australia_router.router)
+app.include_router(botc_router.router)
+app.include_router(caco_router.router)
+
+@app.get("/")
+async def root(request: Request):
+    # Redireciona a raiz direto para o login
+    return templates.TemplateResponse(request=request, name="login.html", context={})

src/routers/__init__.py

@@ -0,0 +1,5 @@
+from .dependencias import obter_usuario_logado
+
+__all__ = [
+    "obter_usuario_logado"
+]

src/routers/australia_router.py

@@ -0,0 +1,97 @@
+from pathlib import Path
+from typing import Annotated
+
+from fastapi import APIRouter, Depends, Request
+from fastapi.responses import HTMLResponse, RedirectResponse
+from fastapi.templating import Jinja2Templates
+
+from src.autenticacao.base import Usuario
+
+from .dependencias import obter_usuario_logado
+
+# Pega o diretório absoluto onde o main.py está (a pasta src/)
+BASE_DIR = Path(__file__).resolve().parent.parent
+
+router = APIRouter(prefix="/australia", tags=["Australia"])
+templates = Jinja2Templates(directory=str(BASE_DIR / "templates"))
+
+@router.get("/votar", response_class=HTMLResponse)
+async def tela_votacao(request: Request, usuario: Annotated[Usuario, Depends(obter_usuario_logado)]):
+    # Valida apenas a permissão da pauta, pois o Depends já garantiu o login
+    if "AUSTRALIA" not in usuario.escopo:
+        return RedirectResponse(url="/", status_code=302)
+
+    eleicao = request.app.state.eleicao_australia
+    candidatos_reais = list(eleicao.candidatos)
+
+    return templates.TemplateResponse(
+        name="australia.html", 
+        request=request,
+        context={"candidatos": candidatos_reais}
+    )    
+
+@router.post("/votar")
+async def processar_voto_australia(request: Request, usuario: Annotated [Usuario, Depends(obter_usuario_logado)]):
+    if "AUSTRALIA" not in usuario.escopo:
+        # Redirect para a raiz em caso de fraude de escopo:
+        return RedirectResponse(url="/", status_code=302)
+
+    # Recupera a eleição do estado global
+    eleicao = request.app.state.eleicao_australia 
+    candidatos_reais = list(eleicao.candidatos.keys()) if isinstance(eleicao.candidatos, dict) else eleicao.candidatos
+
+    # Verifica se o usuário logado já votou
+    if usuario.id in request.app.state.eleitores_australia_votaram:
+        return templates.TemplateResponse(
+            request=request, 
+            name="australia.html", 
+            context={
+                "candidatos": candidatos_reais, 
+                "erro": "Você já registrou seu voto nesta eleição."
+            }
+        )
+
+    form_data = await request.form()
+
+    # Coleta e ordena os candidatos com base nos números digitados
+    tuplas_posicao = []
+    for chave, valor in form_data.items():
+        if chave.startswith("posicao_") and valor.strip().isdigit():
+            nome_candidato = chave.replace("posicao_", "")
+            tuplas_posicao.append((int(valor), nome_candidato))
+
+    # Ordena a lista pela nota (1, 2, 3...)
+    tuplas_posicao.sort(key=lambda x: x[0])
+    cedula_ordenada = [candidato for posicao, candidato in tuplas_posicao]
+
+    try:
+        # O usuário não pode pular candidatos
+        if len(cedula_ordenada) != len(eleicao.candidatos):
+            raise ValueError(f"Erro: Você ranqueou {len(cedula_ordenada)} candidatos. Você deve ranquear exatamente todos os {len(candidatos_reais)} candidatos.")
+
+        posicoes_originais = [pos for pos, cand in tuplas_posicao]
+        posicoes_esperadas = list(range(1, len(candidatos_reais) + 1))
+
+        if sorted(posicoes_originais) != posicoes_esperadas:
+                    raise ValueError("As posições informadas são inválidas. Não é permitido repetir números ou pular posições.\nInsira um número diferente para cada candidato.")
+
+        # Deposita a cédula na urna
+        eleicao.cedulas.append(cedula_ordenada) 
+
+        # Marca que este usuário já votou
+        request.app.state.eleitores_australia_votaram.add(usuario.id)
+
+        return templates.TemplateResponse(
+            request=request, 
+            name="sucesso.html", 
+            context={"mensagem": "Voto registrado com sucesso na Eleição Federal!"}
+        )
+    except ValueError as e:
+        return templates.TemplateResponse(
+            request=request, 
+            name="australia.html",  
+            context={
+                "candidatos": candidatos_reais, 
+                "erro": str(e)
+            }
+        )

src/routers/auth_router.py

@@ -0,0 +1,134 @@
+from pathlib import Path
+from typing import Annotated
+
+from fastapi import APIRouter, Depends, Form, Request
+from fastapi.responses import HTMLResponse, RedirectResponse
+from fastapi.templating import Jinja2Templates
+
+from src.autenticacao.australia import CandidatoAustralia, EleitorAustralia
+from src.autenticacao.base import Usuario
+from src.autenticacao.botc import JogadorBOTC, StoryTellerBOTC
+from src.autenticacao.caco import EstudanteCACo, GestaoCACo
+
+from .dependencias import obter_usuario_logado
+
+# Pega o diretório absoluto onde o main.py está (a pasta src/)
+BASE_DIR = Path(__file__).resolve().parent.parent
+
+router = APIRouter()
+templates = Jinja2Templates(directory=str(BASE_DIR / "templates"))
+
+@router.get("/admin", response_class=HTMLResponse)
+async def painel_admin(request: Request, usuario: Annotated [Usuario, Depends(obter_usuario_logado)]):
+    # Impede que usuários comuns entrem na tela de gestão
+    if "GESTAO" not in usuario.escopo and "STORYTELLER" not in usuario.escopo:
+        return RedirectResponse(url="/dashboard")
+
+    return templates.TemplateResponse(request=request, name="admin.html", context={"usuario": usuario})
+
+@router.get("/cadastro", response_class=HTMLResponse)
+async def tela_cadastro(request: Request):
+    return templates.TemplateResponse(request=request, name="cadastro.html", context={})
+
+@router.post("/cadastro")
+async def processar_cadastro(
+    request: Request,
+    tipo_conta: str = Form(...),
+    username: str = Form(...),
+    senha: str = Form(...),
+    senha_confirma: str = Form(...),
+    nome_real: str = Form(...),
+    ra: str = Form(None) # Opcional no form, obrigatório para EstudanteCACo
+):
+    try:
+        if senha != senha_confirma: # Verifica se as senhas inseridas batem
+            raise ValueError("Senhas não conferem. Tente novamente")
+        banco = request.app.state.banco_auth
+
+        # Análise condicional do tipo de usuário
+        if tipo_conta == "CACO_ESTUDANTE":
+            if not ra or not ra.isnumeric():
+                raise ValueError("RA inválido. Tente novamente.")
+            novo_usuario = EstudanteCACo(username, senha, nome_real, int(ra))
+        elif tipo_conta == "CACO_GESTAO":
+            novo_usuario = GestaoCACo(username, senha, nome_real)
+        elif tipo_conta == "AUSTRALIA_ELEITOR":
+            novo_usuario = EleitorAustralia(username, senha, nome_real)
+        elif tipo_conta == "AUSTRALIA_CANDIDATO":
+            novo_usuario = CandidatoAustralia(username, senha, nome_real)
+        elif tipo_conta == "BOTC_JOGADOR":
+            novo_usuario = JogadorBOTC(username, senha, nome_real)
+        elif tipo_conta == "BOTC_STORYTELLER":
+            novo_usuario = StoryTellerBOTC(username, senha, nome_real)
+        else:
+            raise ValueError("Tipo de conta desconhecido.")
+
+        banco.registrar(novo_usuario)
+
+        # Adiciona alunos e gestores novos na lista de eleitores da assembleia ativa 
+        if tipo_conta in ("CACO_ESTUDANTE", "CACO_GESTAO"):
+            eleicao_caco = request.app.state.eleicao_caco
+            eleicao_caco.alunos_cadastrados.add(novo_usuario.id)
+            eleicao_caco.eleitores.add(novo_usuario.id)
+
+        # Faz o login automático após cadastro
+        resposta = RedirectResponse(url="/dashboard", status_code=302)
+        resposta.set_cookie(key="sessao_usuario", value=username, httponly=True)
+        return resposta
+
+    except ValueError as erro:
+        # Devolve o HTML de erro preenchendo os dados antigos para não apagar a tela
+        return templates.TemplateResponse(
+            request=request,
+            name="cadastro.html",
+            context={
+                "erro": str(erro),
+                "tipo_conta_selecionada": tipo_conta,
+                "nome_real_digitado": nome_real,
+                "username_digitado": username,
+                "ra_digitado": ra
+            }
+        )
+
+@router.post("/login")
+async def processar_login(
+    request: Request, 
+    username: str = Form(...), 
+    senha: str = Form(...)
+):
+    banco = request.app.state.banco_auth
+    try:
+        usuario = banco.login(username, senha)
+
+        # Redireciona para o painel principal após sucesso
+        resposta = RedirectResponse(url="/dashboard", status_code=302)
+
+        # Salva o ID/Username no Cookie do navegador
+        resposta.set_cookie(key="sessao_usuario", value=usuario.username, httponly=True)
+        return resposta
+
+    except ValueError as erro:
+        # Devolve a tela de login com a mensagem de erro (ex: "Senha incorreta")
+        return templates.TemplateResponse(
+            name="login.html", 
+            request=request,
+            context={"erro": str(erro)}
+        )
+
+@router.get("/dashboard")
+async def painel_usuario(request: Request, usuario: Annotated [Usuario, Depends(obter_usuario_logado)]):
+    """A dependência 'obter_usuario_logado' já verifica os cookies.
+    Busca no '_mapa_usernames' e devolve o objeto correto do '_banco_por_id'.
+    Se o cookie não existir, ela mesma já expulsa o usuário para a tela de erro 401.
+    """
+    return templates.TemplateResponse(
+        request=request, 
+        name="dashboard.html", 
+        context={"usuario": usuario}
+    )
+
+@router.get("/logout")
+async def sair(request: Request):
+    resposta = RedirectResponse(url="/")
+    resposta.delete_cookie("sessao_usuario")
+    return resposta