Programação Web II

O que você vai aprender

• Distinguir página estática, página dinâmica, cliente e servidor.
• Acompanhar uma solicitação e uma resposta HTTP.
• Preparar um ambiente local com PHP e confirmar a instalação.
• Organizar o projeto com uma pasta pública.
• Executar o servidor de desenvolvimento do PHP.
• Usar variáveis, tipos básicos, echo e uma decisão com if.
• Combinar PHP e HTML sem perder a estrutura construída no Web I.
• Verificar sintaxe e observar a resposta no DevTools.

Aula 1 — O que muda quando o site vira sistema

Entender: duas páginas podem parecer iguais e funcionar de modos diferentes

Dinâmica não significa apenas ter animações. Um filtro feito com JavaScript no navegador é interativo, mas não dá à proprietária uma visão central dos pedidos. Neste curso, uma página dinâmica no servidor é aquela cuja resposta pode ser construída por uma aplicação conforme dados e regras.

O caminho da primeira página PHP

HTTP em linguagem simples

Aula 2 — Preparando o ambiente PHP

No Web I, o navegador conseguia abrir os arquivos diretamente. Agora precisamos de um programa que leia index.php, execute as instruções e entregue apenas o resultado. Usaremos o PHP 8.5 e seu servidor embutido para desenvolvimento local.

Instalação no Windows

1. Acesse a página oficial do PHP para Windows.
2. Na versão 8.5, escolha o pacote x64 Non Thread Safe em ZIP. Essa opção é adequada ao uso pela linha de comando deste curso.
3. Extraia o conteúdo para uma pasta simples, por exemplo C:\php.
4. Adicione C:\php à variável de usuário Path e reinicie o VS Code.
5. Se o Windows informar que falta um componente de execução, instale o Visual C++ Redistributable 2015–2022 x64 indicado na própria página do PHP.

Em macOS ou Linux, instale uma versão 8.5 suportada pelo gerenciador de pacotes do sistema e faça a mesma conferência abaixo. Em laboratório, siga o procedimento definido pelo responsável pelos computadores.

Confirme no terminal do VS Code

Abra Terminal → Novo Terminal e execute:

php -v

A primeira linha deve informar PHP 8.5. O número depois de 8.5 pode ser diferente, pois correções são publicadas ao longo do tempo.

Validação do editor

O VS Code já oferece suporte básico a PHP e usa o executável para verificar sintaxe. Se o PHP estiver instalado, mas o editor não o localizar, abra as configurações em JSON e informe:

"php.validate.executablePath": "C:/php/php.exe"

Aula 3 — Reorganizando o Café Aurora e iniciando o servidor

Faça uma cópia da versão final criada no Web I e nomeie a nova pasta como cafe-aurora-web2. Assim, a versão publicada continua preservada enquanto o sistema evolui.

Crie uma fronteira pública

Dentro da nova pasta, crie public e mova para ela as páginas, imagens, estilos, scripts e dados do site. O arquivo de orientações pode permanecer na raiz. Depois, renomeie index.html para index.php e atualize os links que ainda apontam para index.html.

Inicie o servidor na raiz do projeto

php -S localhost:8000 -t public

• php inicia o interpretador.
• -S solicita o servidor de desenvolvimento.
• localhost:8000 define o endereço e a porta.
• -t public define a pasta pública do projeto.

Mantenha esse terminal aberto e visite http://localhost:8000. Para encerrar o servidor, volte ao terminal e pressione Ctrl + C.

Aula 4 — A primeira resposta dinâmica do Café Aurora

Agora a proprietária precisa comunicar três informações: o nome do negócio, se os pedidos estão abertos e o tempo estimado de preparo. Em vez de repetir textos pelo HTML, vamos representar esses dados no início de public/index.php.

Programar: entre no modo PHP

Na primeira linha do arquivo, acrescente:

<?php
$nomeNegocio = "Café Aurora";
$pedidosAbertos = true;
$tempoEstimado = 25;

Reconheça os tipos sem complicar

Decida a mensagem com if

A aplicação deve preparar uma mensagem para cada situação. Acrescente antes do HTML:

if ($pedidosAbertos) {
    $mensagemStatus = "Pedidos para retirada estão abertos.";
    $mensagemTempo = "Tempo estimado: $tempoEstimado minutos.";
} else {
    $mensagemStatus = "Pedidos para retirada estão encerrados.";
    $mensagemTempo = "Consulte novamente durante o horário de atendimento.";
}
?>

O bloco do if é executado quando a condição vale true. O bloco do else cobre a outra situação. As chaves delimitam cada bloco.

Mostre os valores dentro do HTML

Substitua o texto fixo do título principal e acrescente a nova seção de atendimento:

<h1><?= $nomeNegocio ?></h1>

<section aria-labelledby="status-pedidos">
  <h2 id="status-pedidos">Pedidos para retirada</h2>
  <p><?= $mensagemStatus ?></p>
  <p><?= $mensagemTempo ?></p>
</section>

A forma <?= ... ?> imprime um valor no ponto exato do documento. Ela é uma forma curta de usar echo. Os valores deste exemplo foram definidos pelo próprio programa; dados recebidos de pessoas exigirão validação e saída segura, assunto dos próximos capítulos.

<?php
$nomeNegocio = "Café Aurora";
$pedidosAbertos = true;
$tempoEstimado = 25;

if ($pedidosAbertos) {
    $mensagemStatus = "Pedidos para retirada estão abertos.";
    $mensagemTempo = "Tempo estimado: $tempoEstimado minutos.";
} else {
    $mensagemStatus = "Pedidos para retirada estão encerrados.";
    $mensagemTempo = "Consulte novamente durante o horário de atendimento.";
}
?>
<!DOCTYPE html>
<html lang="pt-BR">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <meta name="description" content="Conheça o Café Aurora, seus produtos artesanais, ambiente e horário de atendimento.">
  <title>Café Aurora — Café e produtos artesanais no bairro</title>
  <link rel="stylesheet" href="css/styles.css">
</head>
<body>
  <a class="skip-link" href="#conteudo">Pular para o conteúdo</a>
  <header>
    <p><a href="index.php">Café Aurora</a></p>
    <nav aria-label="Navegação principal">
      <ul>
        <li><a href="index.php" aria-current="page">Início</a></li>
        <li><a href="cardapio.html">Cardápio</a></li>
        <li><a href="sobre.html">Sobre</a></li>
        <li><a href="contato.html">Contato</a></li>
      </ul>
    </nav>
  </header>
  <main id="conteudo" tabindex="-1">
    <h1><?= $nomeNegocio ?></h1>
    <p>Café, encontros e bons momentos no coração do bairro.</p>
    <section aria-labelledby="status-pedidos">
      <h2 id="status-pedidos">Pedidos para retirada</h2>
      <p><?= $mensagemStatus ?></p>
      <p><?= $mensagemTempo ?></p>
    </section>
    <section aria-labelledby="destaques">
      <h2 id="destaques">Destaques da casa</h2>
      <p>Cafés selecionados, pães artesanais e receitas preparadas diariamente.</p>
      <p><a href="cardapio.html">Conheça o cardápio</a></p>
    </section>
    <section aria-labelledby="ambiente">
      <h2 id="ambiente">Um ambiente acolhedor</h2>
      <figure>
        <img
          src="img/ambiente-cafe-1024.webp"
          srcset="img/ambiente-cafe-640.webp 640w, img/ambiente-cafe-1024.webp 1024w, img/ambiente-cafe.webp 1280w"
          sizes="(max-width: 48rem) calc(100vw - 2rem), 70rem"
          alt="Salão do Café Aurora com mesas de madeira e plantas"
          width="1280"
          height="853"
        >
        <figcaption>Um espaço para conversar, estudar ou trabalhar.</figcaption>
      </figure>
    </section>
  </main>
  <footer><p>&copy; 2026 Café Aurora. Projeto educacional fictício.</p></footer>
  <script src="js/script.js" defer></script>
</body>
</html>

Aula 5 — Conferindo o que o servidor realmente entregou

Verifique a sintaxe sem abrir o navegador

Em outro terminal, ainda na raiz do projeto, execute:

php -l public/index.php

A resposta esperada informa que nenhum erro de sintaxe foi detectado. Esse teste encontra problemas de escrita da linguagem, como um ponto e vírgula ausente; ele não prova que a regra de negócio está correta.

Observe a resposta no navegador

1. Com o servidor ativo, acesse http://localhost:8000.
2. Use Ver código-fonte da página pelo menu do navegador.
3. Procure $pedidosAbertos e depois procure a mensagem apresentada na tela.

A variável não aparece, mas o texto produzido aparece. Isso comprova uma ideia central: o PHP foi executado no servidor; o navegador recebeu o HTML resultante.

Volte ao Network

No DevTools, selecione a requisição do documento e observe:

• Headers: endereço, método GET e status 200;
• Response: o HTML devolvido pelo servidor;
• Initiator: a navegação que iniciou a solicitação.

O que você vai aprender

• Reconhecer caminho, Query String, parâmetro, nome e valor.
• Entender quando o método GET é adequado.
• Ler um parâmetro com a superglobal $_GET.
• Definir um valor padrão com o operador ??.
• Validar uma categoria usando array e in_array().
• Construir um formulário de consulta com method="get".
• Renderizar somente os produtos solicitados.
• Observar a nova requisição no painel Network.

Aula 1 — Lendo a intenção escrita na URL

Entender: decomponha o endereço

• O sinal ? inicia a Query String.
• categoria é o nome do parâmetro.
• bebida é o valor enviado.
• Quando há mais parâmetros, o caractere & separa cada par.

Quando usar GET

GET é adequado para consultar algo sem alterar o estado do sistema. O resultado pode ser recarregado, favoritado e compartilhado. Filtros e buscas são bons exemplos.

Aula 2 — Recebendo e validando a categoria

Renomeie public/cardapio.html para public/cardapio.php. Depois, atualize em todas as páginas os links que ainda apontam para o nome antigo. O conteúdo visual continua válido; a nova extensão permite que o servidor execute PHP antes de responder.

Leia o valor recebido

No início de cardapio.php, antes do DOCTYPE, escreva:

<?php
$categoria = $_GET["categoria"] ?? "todos";
?>

Receber não significa confiar

Qualquer pessoa pode alterar a URL. Portanto, não basta verificar se o parâmetro existe. Defina os únicos valores aceitos e recupere o padrão se chegar algo diferente:

$categoriasPermitidas = ["todos", "bebida", "comida"];

if (!in_array($categoria, $categoriasPermitidas, true)) {
    $categoria = "todos";
}

• [...] cria um array com valores relacionados.
• in_array() procura a categoria dentro do array.
• ! inverte o resultado: o bloco executa quando o valor não está na lista.
• O terceiro argumento true exige comparação estrita de valor e tipo.

Aula 3 — Criando uma consulta que qualquer pessoa consegue usar

Digitar parâmetros manualmente ajuda a compreender o mecanismo, mas não é uma interface adequada para clientes. Acrescente antes da grade de produtos:

<form method="get" action="cardapio.php">
  <label for="categoria">Categoria</label>
  <select id="categoria" name="categoria">
    <option value="todos"<?php if ($categoria === "todos") { echo " selected"; } ?>>Todos</option>
    <option value="bebida"<?php if ($categoria === "bebida") { echo " selected"; } ?>>Bebidas</option>
    <option value="comida"<?php if ($categoria === "comida") { echo " selected"; } ?>>Comidas</option>
  </select>
  <button type="submit">Consultar no servidor</button>
</form>

• method="get" coloca os controles bem-sucedidos na Query String.
• action="cardapio.php" indica quem receberá a consulta.
• O atributo name fornece o nome do parâmetro; value, seu valor.
• === compara valor e tipo sem conversões automáticas.
• selected mantém visível a opção usada na resposta atual.

Renderize somente o grupo pedido

Envolva o card do café coado com a condição de bebida:

<?php if ($categoria === "todos" || $categoria === "bebida"): ?>
  <article data-categoria="bebida">
    <!-- Preserve aqui o card completo do café coado. -->
  </article>
<?php endif; ?>

Nos dois cards de alimento, use a mesma estrutura trocando bebida por comida. O operador || significa “ou”: o card aparece quando a consulta pede todos ou sua categoria específica. A forma com dois-pontos e endif facilita reconhecer onde começa e termina uma condição misturada ao HTML.

<?php
$categoria = $_GET["categoria"] ?? "todos";
$categoriasPermitidas = ["todos", "bebida", "comida"];

if (!in_array($categoria, $categoriasPermitidas, true)) {
    $categoria = "todos";
}
?>

<form method="get" action="cardapio.php">
  <label for="categoria">Categoria</label>
  <select id="categoria" name="categoria">
    <option value="todos"<?php if ($categoria === "todos") { echo " selected"; } ?>>Todos</option>
    <option value="bebida"<?php if ($categoria === "bebida") { echo " selected"; } ?>>Bebidas</option>
    <option value="comida"<?php if ($categoria === "comida") { echo " selected"; } ?>>Comidas</option>
  </select>
  <button type="submit">Consultar no servidor</button>
</form>

<div class="grade-produtos" id="lista-produtos">
  <?php if ($categoria === "todos" || $categoria === "bebida"): ?>
    <article data-categoria="bebida">
      <h3>Café coado</h3>
      <img src="img/cafe-coado.webp" alt="Xícara de café coado ao lado de uma pequena jarra" width="960" height="640" loading="lazy">
      <p>Preparado na hora com grãos selecionados. <strong>R$ 8,00</strong></p>
    </article>
  <?php endif; ?>

  <?php if ($categoria === "todos" || $categoria === "comida"): ?>
    <article data-categoria="comida">
      <h3>Pão artesanal</h3>
      <img src="img/pao-artesanal.webp" alt="Pão artesanal cortado sobre uma mesa de madeira" width="960" height="640" loading="lazy">
      <p>Fermentação lenta e produção diária. <strong>R$ 12,00</strong></p>
    </article>
    <article data-categoria="comida">
      <h3>Bolo caseiro de laranja</h3>
      <img src="img/bolo-caseiro.webp" alt="Bolo caseiro de laranja com uma fatia servida" width="960" height="640" loading="lazy">
      <p>Receita da casa com laranjas frescas. <strong>R$ 9,00 a fatia</strong></p>
    </article>
  <?php endif; ?>
</div>

Aula 4 — Servidor e navegador trabalhando sem competir

O Café Aurora já possuía um filtro rápido em JavaScript. Agora existem duas camadas úteis: o servidor entrega a categoria solicitada na URL; depois que a página chega, o JavaScript pode permitir novas trocas instantâneas naquele navegador.

No checkpoint, o JavaScript preserva a categoria inicial recebida do servidor quando atualiza os produtos pelo JSON. Isso mantém a melhoria do Web I sem apagar o comportamento novo do Web II.

Entregue a categoria inicial ao JavaScript

No elemento body de cardapio.php, registre a categoria que já foi validada:

<body data-categoria-inicial="<?= $categoria ?>">

No início de js/script.js, leia esse atributo e substitua a chamada inicial filtrarProdutos("todos"):

const categoriaInicial = document.body.dataset.categoriaInicial || "todos";

botoesFiltro.forEach(function (item) {
  item.setAttribute(
    "aria-pressed",
    String(item.dataset.filtro === categoriaInicial)
  );
});

filtrarProdutos(categoriaInicial);

data-categoria-inicial transporta para o navegador um valor já aprovado pelo servidor. A propriedade dataset.categoriaInicial lê esse valor; String() converte o resultado booleano para o texto esperado por aria-pressed.

Veja as duas requisições no Network

1. Abra Network e limpe a lista.
2. Escolha Bebidas no formulário e envie.
3. Localize o documento cardapio.php?categoria=bebida.
4. Depois, clique em Comidas no filtro rápido e confirme que não surgiu outro documento.

O que você vai aprender

• Distinguir GET e POST conforme a intenção da operação.
• Relacionar method, action e name ao envio do formulário.
• Detectar uma requisição POST e ler campos com $_POST.
• Normalizar textos com trim().
• Validar presença, tamanho, e-mail e opções permitidas no servidor.
• Escapar valores apresentados no HTML com htmlspecialchars().
• Preservar os dados válidos e mostrar erros associados aos campos.
• Investigar o envio no painel Network do DevTools.

Aula 1 — Escolhendo POST pela intenção

Entender: consultar não é o mesmo que entregar uma mensagem

POST evita colocar o conteúdo do formulário na URL e expressa que estamos solicitando um processamento. Entretanto, POST não criptografa dados. Em produção, HTTPS continua necessário, e o formulário não deve pedir informações que o negócio não precisa.

Prepare a página que receberá os dados

1. Renomeie public/contato.html para public/contato.php.
2. Atualize em todas as páginas os links que ainda apontam para contato.html.
3. No formulário, troque o destino por action="contato.php" e preserve method="post".

<form action="contato.php" method="post" aria-describedby="orientacao-formulario">

action identifica o recurso que processará os dados. method define como a requisição será feita. Cada controle só ganha um par no envio quando possui name.

Aula 2 — Recebendo sem confiar

No início de contato.php, descubra se a página foi aberta normalmente ou recebeu um envio:

<?php
$formularioEnviado = ($_SERVER["REQUEST_METHOD"] ?? "GET") === "POST";
$mensagemAceita = false;
$erros = [];
?>

$_SERVER["REQUEST_METHOD"] informa o método HTTP usado. A comparação estrita produz true apenas para POST. As outras variáveis guardarão o resultado da validação.

Leia e normalize os campos

Como cada controle deve produzir um único texto, crie uma função que também recuse formatos inesperados:

function textoPost(string $campo): string
{
    $valor = $_POST[$campo] ?? "";
    return is_string($valor) ? trim($valor) : "";
}

$nome = textoPost("nome");
$email = textoPost("email");
$telefone = textoPost("telefone");
$assunto = textoPost("assunto");
$mensagem = textoPost("mensagem");

• $_POST reúne os pares enviados por este formulário POST.
• ?? "" fornece texto vazio quando um campo não chegou.
• is_string() confirma que chegou um único texto, como o formulário espera.
• trim() remove espaços do início e do fim; não corrige nem valida o conteúdo.

Experimento no Elements

1. Inspecione o campo de mensagem.
2. Apague temporariamente required e minlength="10" no painel Elements.
3. Tente enviar uma mensagem vazia.
4. Recarregue a página e confirme que os atributos voltaram: a alteração no DevTools não modificou o arquivo.

Esse teste demonstra por que o servidor não pode depender somente das restrições do HTML.

Aula 3 — Aplicando regras claras

O café aceita três assuntos e precisa de informações suficientes para responder. Defina as opções no PHP e valide apenas quando houver envio:

$assuntosPermitidos = [
    "duvida" => "Dúvida",
    "encomenda" => "Encomenda",
    "sugestao" => "Sugestão"
];

if ($formularioEnviado) {
    if (tamanhoTexto($nome) < 2) {
        $erros["nome"] = "Informe um nome com pelo menos 2 caracteres.";
    }

    if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
        $erros["email"] = "Informe um endereço de e-mail válido.";
    }

    if (!array_key_exists($assunto, $assuntosPermitidos)) {
        $erros["assunto"] = "Escolha um assunto disponível.";
    }

    $tamanhoMensagem = tamanhoTexto($mensagem);
    if ($tamanhoMensagem < 10 || $tamanhoMensagem > 500) {
        $erros["mensagem"] = "Escreva uma mensagem entre 10 e 500 caracteres.";
    }

    if ($erros === []) {
        $mensagemAceita = true;
    }
}

• O array associativo liga o valor técnico ao rótulo apresentado.
• array_key_exists() impede assuntos inventados fora do formulário.
• filter_var() verifica o formato do e-mail; não confirma que a caixa postal existe.
• O telefone é opcional e ainda não tem uma regra de negócio que justifique rejeitá-lo.

Conte caracteres sem depender de uma única instalação

Antes da validação, crie uma função pequena. Quando a extensão mbstring está disponível, ela conta caracteres multibyte corretamente; o retorno alternativo evita interromper o exercício em uma instalação sem essa extensão.

function tamanhoTexto(string $texto): int
{
    if (function_exists("mb_strlen")) {
        return mb_strlen($texto);
    }

    return strlen($texto);
}

Aula 4 — Respondendo com segurança e clareza

Escape no momento de escrever no HTML

Um nome pode conter caracteres que o navegador interpretaria como marcação. Crie esta função antes do HTML:

function escapar(string $valor): string
{
    return htmlspecialchars(
        $valor,
        ENT_QUOTES | ENT_SUBSTITUTE,
        "UTF-8"
    );
}

Validação responde “este dado atende à regra?”. Escape responde “como mostrar este texto com segurança neste HTML?”. São etapas complementares, não substitutas.

Mostre um resumo que também ajuda a corrigir

<?php if ($mensagemAceita): ?>
  <div class="mensagem-sucesso" role="status">
    <strong>Mensagem recebida e validada.</strong>
    <p>Nesta demonstração, ela ainda não foi armazenada nem enviada.</p>
  </div>
<?php elseif ($formularioEnviado): ?>
  <div class="resumo-erros" role="alert">
    <strong>Revise os campos indicados:</strong>
    <ul>
      <?php foreach ($erros as $campo => $erro): ?>
        <li><a href="#<?= escapar($campo) ?>"><?= escapar($erro) ?></a></li>
      <?php endforeach; ?>
    </ul>
  </div>
<?php endif; ?>

Preserve um valor para a pessoa não recomeçar

<input
  type="text"
  id="nome"
  name="nome"
  value="<?= escapar($nome) ?>"
  minlength="2"
  required
>

Aplique o mesmo princípio ao e-mail, telefone e mensagem. No select, use uma comparação estrita para devolver selected à opção recebida. O checkpoint contém a página completa.

<?php
function tamanhoTexto(string $texto): int
{
    if (function_exists("mb_strlen")) {
        return mb_strlen($texto);
    }

    return strlen($texto);
}

function escapar(string $valor): string
{
    return htmlspecialchars($valor, ENT_QUOTES | ENT_SUBSTITUTE, "UTF-8");
}

function textoPost(string $campo): string
{
    $valor = $_POST[$campo] ?? "";
    return is_string($valor) ? trim($valor) : "";
}

$formularioEnviado = ($_SERVER["REQUEST_METHOD"] ?? "GET") === "POST";
$mensagemAceita = false;
$erros = [];
$assuntosPermitidos = [
    "duvida" => "Dúvida",
    "encomenda" => "Encomenda",
    "sugestao" => "Sugestão"
];

$nome = textoPost("nome");
$email = textoPost("email");
$telefone = textoPost("telefone");
$assunto = textoPost("assunto");
$mensagem = textoPost("mensagem");

if ($formularioEnviado) {
    if (tamanhoTexto($nome) < 2) {
        $erros["nome"] = "Informe um nome com pelo menos 2 caracteres.";
    }
    if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
        $erros["email"] = "Informe um endereço de e-mail válido.";
    }
    if (!array_key_exists($assunto, $assuntosPermitidos)) {
        $erros["assunto"] = "Escolha um assunto disponível.";
    }
    $tamanhoMensagem = tamanhoTexto($mensagem);
    if ($tamanhoMensagem < 10 || $tamanhoMensagem > 500) {
        $erros["mensagem"] = "Escreva uma mensagem entre 10 e 500 caracteres.";
    }

    $mensagemAceita = $erros === [];
}

Investigue a resposta no Network

1. Envie dados válidos e abra a requisição contato.php.
2. Confirme método POST, status 200 e os campos em Payload.
3. Repita com um e-mail inválido usando a alteração temporária no Elements.
4. Compare a resposta HTML e confirme que o PHP rejeitou o dado mesmo sem a proteção do navegador.

O que você vai aprender

• Reconhecer por que atualizar uma resposta POST pode reenviar dados.
• Compreender o padrão POST–Redirect–GET.
• Enviar um cabeçalho de redirecionamento com header().
• Usar o status 303 para solicitar uma nova navegação GET.
• Encerrar o processamento com exit.
• Iniciar uma sessão e trabalhar com $_SESSION.
• Criar uma mensagem temporária, apresentada uma única vez.
• Observar redirecionamento, status e cookie de sessão no DevTools.

Aula 1 — Enxergando o reenvio acidental

Entender: a página atual nasceu de qual requisição?

No fim do capítulo anterior, um envio válido produz diretamente uma resposta HTML. A barra de endereço mostra contato.php, mas o documento foi obtido por POST. O endereço sozinho não revela o método usado.

O fluxo que queremos construir

Esse encadeamento é conhecido como POST–Redirect–GET, ou PRG. Ele reduz reenvios causados por atualização e pelo botão voltar. Não substitui validação, HTTPS nem outras proteções da operação.

Aula 2 — Uma pequena memória entre requisições

HTTP não entrega automaticamente ao próximo acesso as variáveis criadas no POST. Uma sessão permite manter dados associados àquele navegador entre requisições. Em uma configuração comum, o servidor guarda os dados e o navegador recebe um cookie com o identificador da sessão.

Inicie ou retome a sessão

Na primeira linha PHP de contato.php, antes de qualquer HTML, espaço fora do PHP ou texto enviado ao navegador, acrescente:

session_start();

session_start() cria uma sessão ou retoma a sessão identificada na requisição. Ela também pode enviar cabeçalhos HTTP; por isso precisa executar antes da saída da página.

Leia e remova uma mensagem de uso único

Logo depois das funções do arquivo, recupere a mensagem e retire-a da sessão:

$mensagemTemporaria = $_SESSION["mensagem_temporaria"] ?? "";
unset($_SESSION["mensagem_temporaria"]);

• $_SESSION é o array da sessão atual.
• ?? "" oferece um padrão quando não há mensagem.
• unset() remove a entrada da sessão.
• A variável local continua com o texto durante a resposta atual; na próxima atualização, a sessão já não o possui.

Aula 3 — Redirecionando depois da validação

No Capítulo 3, o resultado válido apenas alterava $mensagemAceita. Substitua essa atribuição pelo armazenamento temporário e pelo redirecionamento:

if ($erros === []) {
    $_SESSION["mensagem_temporaria"] =
        "Mensagem recebida e validada. " .
        "Nesta demonstração, ela ainda não foi armazenada nem enviada.";

    header("Location: contato.php", true, 303);
    exit;
}

Mostre a mensagem trazida pelo GET

No HTML, substitua a antiga condição de sucesso:

<?php if ($mensagemTemporaria !== ""): ?>
  <div class="mensagem-sucesso" role="status">
    <strong><?= escapar($mensagemTemporaria) ?></strong>
  </div>
<?php elseif ($formularioEnviado): ?>
  <!-- Preserve aqui o resumo de erros do Capítulo 3. -->
<?php endif; ?>

Um POST inválido não redireciona: a mesma resposta preserva os valores e mostra os erros para correção. Somente o caminho válido produz 303 e uma página GET limpa.

<?php
session_start();

function tamanhoTexto(string $texto): int
{
    if (function_exists("mb_strlen")) {
        return mb_strlen($texto);
    }
    return strlen($texto);
}

function escapar(string $valor): string
{
    return htmlspecialchars($valor, ENT_QUOTES | ENT_SUBSTITUTE, "UTF-8");
}

function textoPost(string $campo): string
{
    $valor = $_POST[$campo] ?? "";
    return is_string($valor) ? trim($valor) : "";
}

$mensagemTemporaria = $_SESSION["mensagem_temporaria"] ?? "";
unset($_SESSION["mensagem_temporaria"]);

$formularioEnviado = ($_SERVER["REQUEST_METHOD"] ?? "GET") === "POST";
$erros = [];
$assuntosPermitidos = [
    "duvida" => "Dúvida",
    "encomenda" => "Encomenda",
    "sugestao" => "Sugestão"
];

$nome = textoPost("nome");
$email = textoPost("email");
$telefone = textoPost("telefone");
$assunto = textoPost("assunto");
$mensagem = textoPost("mensagem");

if ($formularioEnviado) {
    if (tamanhoTexto($nome) < 2) {
        $erros["nome"] = "Informe um nome com pelo menos 2 caracteres.";
    }
    if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
        $erros["email"] = "Informe um endereço de e-mail válido.";
    }
    if (!array_key_exists($assunto, $assuntosPermitidos)) {
        $erros["assunto"] = "Escolha um assunto disponível.";
    }
    $tamanhoMensagem = tamanhoTexto($mensagem);
    if ($tamanhoMensagem < 10 || $tamanhoMensagem > 500) {
        $erros["mensagem"] =
            "Escreva uma mensagem entre 10 e 500 caracteres.";
    }

    if ($erros === []) {
        $_SESSION["mensagem_temporaria"] =
            "Mensagem recebida e validada. " .
            "Nesta demonstração, ela ainda não foi armazenada nem enviada.";

        header("Location: contato.php", true, 303);
        exit;
    }
}
?>

Aula 4 — Provando o novo fluxo no navegador

Acompanhe POST, 303 e GET

1. Abra Network, ative Preserve log ou Preservar registro e limpe a lista.
2. Envie uma mensagem válida.
3. Localize a requisição POST com status 303 e confira o cabeçalho Location: contato.php.
4. Localize logo depois a requisição GET com status 200.
5. Atualize a página: deverá surgir outro GET, sem aviso de reenvio e sem repetir a confirmação.

Localize a sessão sem expor seu identificador

No DevTools, abra Application → Cookies ou a área equivalente do seu navegador. Na configuração padrão do PHP, você geralmente encontrará um cookie chamado PHPSESSID. Ele identifica a sessão; a frase de confirmação continua no servidor. Não copie o valor para relatórios ou capturas compartilhadas.

O que você vai aprender

• Distinguir sessão, arquivo de conteúdo e banco de dados.
• Entender por que SQLite é adequado para esta etapa.
• Reconhecer banco, tabela, linha, coluna, chave primária e restrição.
• Verificar e habilitar o driver pdo_sqlite.
• Manter o banco e o código de acesso fora da pasta pública.
• Criar uma conexão por PDO e compreender seu DSN.
• Preparar uma tabela com CREATE TABLE.
• Executar uma inicialização repetível e conferir seu resultado.

Aula 1 — Escolhendo a memória certa

Entender: nem toda informação deve morar no mesmo lugar

Persistir significa manter a informação além da requisição atual. Isso não autoriza guardar tudo: o negócio deve coletar apenas o necessário, definir por quanto tempo conservar e proteger o acesso.

Por que SQLite agora

SQLite mantém o banco em um arquivo e não exige instalar um serviço de banco separado. Ele é apropriado para aprendizagem, protótipos e aplicações de menor porte executadas em um único servidor. O PHP acessará esse arquivo pelo driver PDO_SQLITE.

Modele a primeira tabela

Em SQLite, o tipo declarado orienta como os valores são tratados, mas sua tipagem é flexível. Por isso também usaremos NOT NULL e CHECK para explicitar regras importantes.

Aula 2 — Preparando o driver e protegendo o arquivo

Confirme os módulos disponíveis

No terminal do VS Code no Windows, execute:

php -m | findstr /I "PDO sqlite"

Procure por PDO e pdo_sqlite. Em macOS ou Linux, use:

php -m | grep -Ei "PDO|sqlite"

Se pdo_sqlite não aparecer

1. Execute php --ini e localize o arquivo de configuração carregado.
2. Se o Windows informar que não carregou nenhum, copie C:\php\php.ini-development para C:\php\php.ini.
3. No php.ini, localize ;extension=pdo_sqlite e remova apenas o ponto e vírgula inicial.
4. Confirme que a pasta indicada por extension_dir contém as extensões da instalação.
5. Encerre e reinicie o servidor PHP; depois execute novamente o comando de conferência.

Crie uma área privada do projeto

Acrescente as pastas src e dados na raiz, ao lado de public:

A opção -t public do servidor impede que o navegador solicite diretamente os arquivos de dados e src. A aplicação PHP continua conseguindo acessá-los pelo sistema de arquivos.

Não versione o banco local

No arquivo .gitignore, acrescente:

/dados/*.sqlite
/dados/*.sqlite-shm
/dados/*.sqlite-wal

Um banco de desenvolvimento pode conter dados pessoais. Mantê-lo fora do Git evita uma publicação acidental, mas não substitui permissões, backups e controle de acesso.

Aula 3 — Criando a conexão PDO

Crie src/banco.php. A função abaixo concentra o endereço e as opções da conexão em um único lugar:

<?php
function conectarBanco(): PDO
{
    $caminhoBanco =
        dirname(__DIR__) . "/dados/cafe-aurora.sqlite";

    return new PDO(
        "sqlite:" . $caminhoBanco,
        null,
        null,
        [
            PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
            PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC
        ]
    );
}

DSN é a descrição da origem dos dados. Para SQLite, ele contém o nome do driver e o caminho do arquivo. Os dois valores null ocupam as posições de usuário e senha, que não são usados nesta conexão local.

Defina um comportamento previsível

• PDO::ERRMODE_EXCEPTION transforma falhas do banco em exceções que o programa pode tratar.
• PDO::FETCH_ASSOC prepara consultas futuras para devolver colunas por seus nomes.
• Centralizar a conexão evita repetir o caminho e as opções em cada página.

Aula 4 — Criando a tabela de forma repetível

Escreva a estrutura em SQL

Em src/inicializar-banco.php, a instrução principal será:

CREATE TABLE IF NOT EXISTS mensagens (
    id INTEGER PRIMARY KEY,
    nome TEXT NOT NULL CHECK (length(nome) >= 2),
    email TEXT NOT NULL,
    telefone TEXT,
    assunto TEXT NOT NULL
        CHECK (assunto IN ('duvida', 'encomenda', 'sugestao')),
    mensagem TEXT NOT NULL
        CHECK (length(mensagem) BETWEEN 10 AND 500),
    criada_em TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
)

• IF NOT EXISTS permite repetir a inicialização sem tentar recriar uma tabela já existente.
• INTEGER PRIMARY KEY fornece uma identidade inteira única. Não precisamos de AUTOINCREMENT neste caso.
• NOT NULL impede ausência de valor.
• CHECK rejeita valores que desrespeitam a expressão.
• DEFAULT CURRENT_TIMESTAMP fornece a data e hora em UTC quando o registro for criado; a apresentação no horário local será tratada depois.

Execute SQL e trate uma possível falha

$pdo->exec($sql) executa uma instrução que não precisa devolver linhas. O operador -> acessa um método do objeto. Como conexão, pasta ou SQL podem falhar, try delimita a tentativa e catch trata a exceção.

<?php
require_once __DIR__ . "/banco.php";

if (!extension_loaded("pdo_sqlite")) {
    fwrite(STDERR, "O driver pdo_sqlite não está ativo." . PHP_EOL);
    exit(1);
}

try {
    $pdo = conectarBanco();

    $sql = "
        CREATE TABLE IF NOT EXISTS mensagens (
            id INTEGER PRIMARY KEY,
            nome TEXT NOT NULL CHECK (length(nome) >= 2),
            email TEXT NOT NULL,
            telefone TEXT,
            assunto TEXT NOT NULL
                CHECK (assunto IN ('duvida', 'encomenda', 'sugestao')),
            mensagem TEXT NOT NULL
                CHECK (length(mensagem) BETWEEN 10 AND 500),
            criada_em TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
        )
    ";

    $pdo->exec($sql);

    $quantidade = (int) $pdo
        ->query("SELECT COUNT(*) FROM mensagens")
        ->fetchColumn();

    echo "Banco e tabela preparados com sucesso." . PHP_EOL;
    echo "Mensagens cadastradas: $quantidade" . PHP_EOL;
} catch (PDOException $erro) {
    fwrite(
        STDERR,
        "Não foi possível preparar o banco: " .
        $erro->getMessage() .
        PHP_EOL
    );
    exit(1);
}

Programe e confira

Na raiz do projeto, execute:

php -l src/banco.php
php -l src/inicializar-banco.php
php src/inicializar-banco.php

O terminal deve informar que o banco e a tabela foram preparados e que existem zero mensagens. O arquivo dados/cafe-aurora.sqlite surgirá nesse momento.

O que você vai aprender

• Reconhecer o limite de confiança entre navegador e servidor.
• Entender, gerar, enviar e verificar um token CSRF.
• Distinguir instrução SQL, marcador e valor.
• Preparar e executar um INSERT com PDO.
• Representar o telefone opcional como null.
• Tratar uma falha do banco sem expor detalhes técnicos à pessoa usuária.
• Manter o PRG depois da gravação.
• Comprovar que a tabela recebeu apenas os registros esperados.

Aula 1 — Proteger antes de gravar

Entender: o navegador está fora da área de confiança

Os atributos HTML ajudam quem preenche o formulário, mas podem ser alterados ou ignorados. Por isso, a validação em PHP continua obrigatória. Agora acrescentaremos duas proteções com responsabilidades diferentes:

O fluxo seguro da mensagem

O token CSRF será secreto, imprevisível e associado à sessão. Ele viajará em um campo oculto do formulário, nunca na URL. O servidor aceitará a alteração somente quando o valor recebido corresponder ao guardado na sessão.

Aula 2 — Criando e conferindo o token CSRF

Gere um token para a sessão

Depois de session_start(), crie o token somente se a sessão ainda não possuir um valor válido:

if (!isset($_SESSION["csrf_token"]) ||
    !is_string($_SESSION["csrf_token"])) {
    $_SESSION["csrf_token"] = bin2hex(random_bytes(32));
}

$csrfToken = $_SESSION["csrf_token"];

• random_bytes(32) produz 32 bytes aleatórios adequados para uso criptográfico.
• bin2hex(...) transforma esses bytes em 64 caracteres hexadecimais fáceis de transportar no HTML.
• Guardar o valor em $_SESSION permite compará-lo quando o POST chegar.

Envie o valor em um campo oculto

Logo após a abertura do formulário, acrescente:

<input
  type="hidden"
  name="csrf_token"
  value="<?= escapar($csrfToken) ?>"
>

hidden não torna o valor secreto para a pessoa que usa o navegador. Ele apenas não cria um controle visível. O segredo importante é outro: uma página de origem diferente não deve conseguir ler o token gerado para esta sessão.

Compare no servidor

No início do processamento do POST, obtenha o valor como texto e faça uma comparação apropriada:

$tokenRecebido = $_POST["csrf_token"] ?? "";

$tokenValido = is_string($tokenRecebido) &&
    hash_equals($csrfToken, $tokenRecebido);

if (!$tokenValido) {
    http_response_code(403);
    $erroGeral =
        "Não foi possível confirmar este envio. " .
        "Atualize a página e tente novamente.";
}

hash_equals() compara as duas sequências de forma resistente a ataques de temporização. O valor conhecido da sessão aparece primeiro; o recebido, depois. Token ausente ou diferente impede a gravação, e o status 403 informa que o servidor recusou a operação.

Aula 3 — Inserindo valores sem montar SQL com texto

Separe a instrução dos dados

Inclua a conexão preparada no capítulo anterior:

require_once dirname(__DIR__) . "/src/banco.php";

Depois que token e campos forem aprovados, prepare o comando:

$pdo = conectarBanco();

$comando = $pdo->prepare(
    "INSERT INTO mensagens
        (nome, email, telefone, assunto, mensagem)
     VALUES
        (:nome, :email, :telefone, :assunto, :mensagem)"
);

Os nomes iniciados por dois-pontos são marcadores. Eles reservam posições para valores; não são variáveis PHP e não recebem aspas manuais.

Execute com os valores validados

$comando->execute([
    "nome" => $nome,
    "email" => $email,
    "telefone" => $telefone !== "" ? $telefone : null,
    "assunto" => $assunto,
    "mensagem" => $mensagem
]);

• As chaves do array correspondem aos marcadores da instrução.
• Um telefone vazio vira null, isto é, ausência de valor no banco.
• criada_em não aparece porque a tabela já possui um valor padrão.
• id também não aparece: o SQLite fornece a próxima identidade inteira.

Trate a falha e preserve o PRG

try {
    // conectar, preparar e executar...

    $_SESSION["mensagem_temporaria"] =
        "Mensagem registrada com sucesso.";
    header("Location: contato.php", true, 303);
    exit;
} catch (PDOException $erro) {
    error_log($erro->getMessage());
    $erroGeral =
        "Não foi possível registrar a mensagem agora. " .
        "Tente novamente.";
}

O detalhe técnico vai para o registro de erros do servidor; a página mostra uma orientação segura. O redirecionamento acontece somente depois da execução bem-sucedida. Se o banco falhar, não devemos anunciar sucesso.

Aula 4 — Integrando e testando a gravação

Ajuste a mensagem da interface

Como os dados agora são persistidos, substitua a orientação antiga por uma descrição verdadeira:

<p id="orientacao-formulario">
  Os campos identificados como obrigatórios devem ser
  preenchidos. A mensagem será armazenada para atendimento.
</p>

<?php
session_start();
require_once dirname(__DIR__) . "/src/banco.php";

function tamanhoTexto(string $texto): int
{
    if (function_exists("mb_strlen")) {
        return mb_strlen($texto);
    }

    return strlen($texto);
}

function escapar(string $valor): string
{
    return htmlspecialchars(
        $valor,
        ENT_QUOTES | ENT_SUBSTITUTE,
        "UTF-8"
    );
}

function textoPost(string $campo): string
{
    $valor = $_POST[$campo] ?? "";
    return is_string($valor) ? trim($valor) : "";
}

if (!isset($_SESSION["csrf_token"]) ||
    !is_string($_SESSION["csrf_token"])) {
    $_SESSION["csrf_token"] = bin2hex(random_bytes(32));
}

$csrfToken = $_SESSION["csrf_token"];

$mensagemTemporaria =
    $_SESSION["mensagem_temporaria"] ?? "";
unset($_SESSION["mensagem_temporaria"]);

$formularioEnviado =
    ($_SERVER["REQUEST_METHOD"] ?? "GET") === "POST";
$erros = [];
$erroGeral = "";
$assuntosPermitidos = [
    "duvida" => "Dúvida",
    "encomenda" => "Encomenda",
    "sugestao" => "Sugestão"
];

$nome = textoPost("nome");
$email = textoPost("email");
$telefone = textoPost("telefone");
$assunto = textoPost("assunto");
$mensagem = textoPost("mensagem");

if ($formularioEnviado) {
    $tokenRecebido = $_POST["csrf_token"] ?? "";
    $tokenValido = is_string($tokenRecebido) &&
        hash_equals($csrfToken, $tokenRecebido);

    if (!$tokenValido) {
        http_response_code(403);
        $erroGeral =
            "Não foi possível confirmar este envio. " .
            "Atualize a página e tente novamente.";
    }

    if (tamanhoTexto($nome) < 2) {
        $erros["nome"] =
            "Informe um nome com pelo menos 2 caracteres.";
    }

    if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
        $erros["email"] =
            "Informe um endereço de e-mail válido.";
    }

    if (!array_key_exists($assunto, $assuntosPermitidos)) {
        $erros["assunto"] =
            "Escolha um assunto disponível.";
    }

    $tamanhoMensagem = tamanhoTexto($mensagem);
    if ($tamanhoMensagem < 10 || $tamanhoMensagem > 500) {
        $erros["mensagem"] =
            "Escreva uma mensagem entre 10 e 500 caracteres.";
    }

    if ($erros === [] && $erroGeral === "") {
        try {
            $pdo = conectarBanco();
            $comando = $pdo->prepare(
                "INSERT INTO mensagens
                    (nome, email, telefone, assunto, mensagem)
                 VALUES
                    (:nome, :email, :telefone, :assunto, :mensagem)"
            );
            $comando->execute([
                "nome" => $nome,
                "email" => $email,
                "telefone" =>
                    $telefone !== "" ? $telefone : null,
                "assunto" => $assunto,
                "mensagem" => $mensagem
            ]);

            $_SESSION["mensagem_temporaria"] =
                "Mensagem registrada com sucesso.";
            header("Location: contato.php", true, 303);
            exit;
        } catch (PDOException $erro) {
            error_log($erro->getMessage());
            $erroGeral =
                "Não foi possível registrar a mensagem agora. " .
                "Tente novamente.";
        }
    }
}
?>

O restante do HTML permanece. Além da orientação e do campo oculto, ajuste apenas o resumo para também mostrar $erroGeral quando existir. O checkpoint contém a página completa para conferência.

Programe e teste em ordem

1. Execute php src/inicializar-banco.php antes de iniciar o servidor.
2. Confira a sintaxe com php -l public/contato.php.
3. Inicie php -S localhost:8000 -t public.
4. Envie uma mensagem válida e confirme o redirecionamento seguido da mensagem de sucesso.
5. Execute novamente php src/inicializar-banco.php; a contagem deve aumentar para 1.
6. Atualize a página de confirmação e confira que a contagem continua 1.

O que você vai aprender

• Distinguir autenticação, autorização e proteção da rota.
• Gerar um hash de senha e verificar a credencial sem guardar a senha original.
• Renovar a identificação da sessão depois da entrada.
• Impedir o acesso direto ao painel sem uma sessão autenticada.
• Consultar registros com SELECT, ORDER BY e LIMIT.
• Aplicar um filtro permitido com consulta preparada.
• Escapar cada dado antes de mostrá-lo no HTML.
• Encerrar a sessão por uma requisição protegida.

Aula 1 — Definindo quem pode entrar

Entender: três perguntas diferentes

Ocultar o link, usar uma pasta chamada admin ou acrescentar noindex não responde a essas perguntas. Qualquer endereço conhecido ainda pode ser solicitado. A verificação precisa acontecer no PHP antes que os dados sejam lidos ou enviados.

Não guarde a senha original

Crie src/criar-administrador.php para receber a credencial no terminal. Depois de validar usuário e tamanho mínimo da senha, transforme-a:

$configuracao = [
    "usuario" => $usuario,
    "senha_hash" => password_hash($senha, PASSWORD_DEFAULT)
];

password_hash() aplica um algoritmo próprio para senhas e inclui as informações necessárias para a verificação futura. O arquivo gerado ficará em dados/administrador.php, fora da raiz pública e ignorado pelo Git.

Crie sua credencial local

php src/criar-administrador.php

Escolha uma senha exclusiva para o exercício, com pelo menos 12 caracteres. Não reutilize a senha de e-mail, rede social ou qualquer serviço real.

Aula 2 — Transformando a entrada em uma sessão protegida

Configure o cookie antes de iniciar a sessão

Em src/autenticacao.php, concentre as funções de acesso. A sessão deve começar com parâmetros apropriados:

session_set_cookie_params([
    "httponly" => true,
    "secure" => !empty($_SERVER["HTTPS"]),
    "samesite" => "Lax"
]);
session_start();

• httponly impede a leitura normal do cookie por JavaScript.
• secure exige HTTPS quando a aplicação está sendo servida por HTTPS.
• samesite reduz o envio do cookie em certos contextos iniciados por outros sites.

Verifique a credencial e renove a sessão

$usuarioCorreto = hash_equals(
    $administrador["usuario"],
    trim($usuario)
);
$senhaCorreta = password_verify(
    $senha,
    $administrador["senha_hash"]
);

if ($usuarioCorreto && $senhaCorreta) {
    session_regenerate_id(true);
    $_SESSION["administrador_autenticado"] = true;
    header("Location: painel.php", true, 303);
    exit;
}

session_regenerate_id(true) troca a identificação da sessão depois da autenticação e remove a anterior. A mensagem de erro deve permanecer genérica: “Usuário ou senha inválidos” não revela qual parte estava correta.

Proteja a rota antes de consultar

No início de public/admin/painel.php, inicie a sessão e interrompa quem ainda não entrou:

iniciarSessaoSegura();
exigirAutenticacao();
header("Cache-Control: no-store");

O cabeçalho no-store orienta navegadores e intermediários a não armazenar a resposta. Ele não substitui autenticação. Do mesmo modo, noindex orienta buscadores, mas não controla acesso.

Aula 3 — Lendo os registros com critérios claros

Consulte somente o necessário

$consulta = $pdo->query(
    "SELECT id, nome, email, telefone, assunto, mensagem, criada_em
     FROM mensagens
     ORDER BY criada_em DESC, id DESC
     LIMIT 50"
);

$mensagens = $consulta->fetchAll();

Valide o filtro antes de construir a consulta

O filtro virá da URL, portanto continua sendo dado externo. Aproveite a mesma lista fechada usada no formulário:

$assuntosPermitidos = [
    "" => "Todos",
    "duvida" => "Dúvida",
    "encomenda" => "Encomenda",
    "sugestao" => "Sugestão"
];

$assunto = $_GET["assunto"] ?? "";
$assunto = is_string($assunto) &&
    array_key_exists($assunto, $assuntosPermitidos)
        ? $assunto
        : "";

Quando houver assunto, use um marcador para o valor:

$consulta = $pdo->prepare(
    "SELECT id, nome, email, telefone, assunto, mensagem, criada_em
     FROM mensagens
     WHERE assunto = :assunto
     ORDER BY criada_em DESC, id DESC
     LIMIT 50"
);
$consulta->execute(["assunto" => $assunto]);

Aula 4 — Mostrando dados sem transformá-los em código

Escape na fronteira de saída

Crie uma função específica para o painel:

function escaparPainel(string $valor): string
{
    return htmlspecialchars(
        $valor,
        ENT_QUOTES | ENT_SUBSTITUTE,
        "UTF-8"
    );
}

Aplique a função a nome, e-mail, telefone, assunto, mensagem e valores usados em atributos HTML. Para preservar quebras de linha da mensagem, escape primeiro e somente depois use nl2br():

<td>
  <?= nl2br(escaparPainel($registro["mensagem"])) ?>
</td>

Inverter a ordem faria htmlspecialchars() neutralizar também os elementos <br> criados pelo programa.

Dê estrutura à tabela

Use caption, cabeçalhos com scope="col" e uma região com rolagem horizontal em telas estreitas. A responsividade não deve ocultar colunas nem misturar o contato de uma pessoa com a mensagem de outra.

Encerre a sessão como uma alteração de estado

O botão Sair deve enviar POST com o token CSRF. Depois da conferência, limpe os dados, remova o cookie e destrua a sessão. Um link GET não é adequado para uma ação que muda o estado de autenticação.

O que você vai aprender

• Distinguir evolução de estrutura e alteração de registros.
• Adicionar colunas a uma tabela existente sem recriá-la.
• Definir estados permitidos no PHP e no banco.
• Enviar ID, estado e token por um formulário administrativo.
• Validar campos ocultos como qualquer outro dado externo.
• Executar UPDATE parametrizado com WHERE.
• Verificar quantas linhas foram afetadas.
• Aplicar POST–Redirect–GET e preservar o filtro do painel.

Aula 1 — Preparando o banco para acompanhar o trabalho

Entender: registro e estrutura não são a mesma coisa

O banco de quem começou no Capítulo 5 já possui a tabela mensagens. Alterar apenas o CREATE TABLE IF NOT EXISTS não modifica essa tabela antiga. Por isso, o inicializador precisa reconhecer quais colunas já existem.

Inspecione antes de alterar

$colunas = $pdo->query(
    "PRAGMA table_info(mensagens)"
)->fetchAll();

$nomesColunas = array_column($colunas, "name");

PRAGMA table_info devolve informações sobre as colunas. array_column() extrai somente os nomes, permitindo decidir se cada pequena migração ainda é necessária.

Adicione somente o que falta

if (!in_array("status", $nomesColunas, true)) {
    $pdo->exec(
        "ALTER TABLE mensagens
         ADD COLUMN status TEXT NOT NULL DEFAULT 'nova'
         CHECK (status IN ('nova', 'em_atendimento', 'respondida'))"
    );
}

if (!in_array("atualizada_em", $nomesColunas, true)) {
    $pdo->exec(
        "ALTER TABLE mensagens
         ADD COLUMN atualizada_em TEXT"
    );
}

Aula 2 — Enviando a intenção de mudar uma mensagem

Inclua o estado na leitura

O painel precisa receber as novas colunas para exibir a situação atual:

SELECT id, nome, email, telefone, assunto, mensagem,
       criada_em, status, atualizada_em
FROM mensagens
ORDER BY criada_em DESC, id DESC
LIMIT 50

Crie um formulário para cada registro

<form method="post" action="atualizar-status.php">
  <input type="hidden" name="csrf_token"
         value="<?= escaparPainel($csrfToken) ?>">
  <input type="hidden" name="id"
         value="<?= (int) $registro["id"] ?>">

  <label for="status-<?= (int) $registro["id"] ?>">
    Andamento
  </label>
  <select id="status-<?= (int) $registro["id"] ?>"
          name="status">
    <!-- Gere somente as opções permitidas. -->
  </select>
  <button type="submit">Atualizar</button>
</form>

O ID identifica a linha que deverá mudar. O token confirma que a solicitação veio da sessão que exibiu o formulário. O estado informa o novo valor. Os três campos podem ser modificados fora da interface, portanto todos precisam ser verificados no servidor.

Preserve o contexto de trabalho

Se a proprietária estiver vendo apenas encomendas, a atualização não deve devolvê-la à lista completa sem necessidade. Envie também assunto_retorno, valide-o pela lista fechada e use-o somente para reconstruir o redirecionamento.

Aula 3 — Atualizando exatamente uma linha

Comece protegendo a rota

Crie public/admin/atualizar-status.php. Antes de ler os campos, exija autenticação, aceite somente POST e confira o token:

iniciarSessaoSegura();
exigirAutenticacao();

if (($_SERVER["REQUEST_METHOD"] ?? "GET") !== "POST") {
    header("Allow: POST");
    http_response_code(405);
    exit("Método não permitido.");
}

if (!tokenCsrfValido($_POST["csrf_token"] ?? "")) {
    http_response_code(403);
    exit("Não foi possível confirmar a alteração.");
}

Valide identidade e estado

$id = filter_var(
    $_POST["id"] ?? "",
    FILTER_VALIDATE_INT,
    ["options" => ["min_range" => 1]]
);

$statusPermitidos = [
    "nova",
    "em_atendimento",
    "respondida"
];

$status = $_POST["status"] ?? "";
$status = is_string($status) ? $status : "";

Um inteiro positivo ainda pode apontar para uma linha inexistente; essa diferença será descoberta depois da execução. Já um estado fora da lista deve ser rejeitado antes de chegar ao banco.

Separe comando e valores

$comando = $pdo->prepare(
    "UPDATE mensagens
     SET status = :status,
         atualizada_em = CURRENT_TIMESTAMP
     WHERE id = :id"
);

$comando->execute([
    "status" => $status,
    "id" => $id
]);

Confira o efeito real

if ($comando->rowCount() === 1) {
    $_SESSION["aviso_admin"] = [
        "tipo" => "sucesso",
        "texto" => "Andamento atualizado com sucesso."
    ];
} else {
    $_SESSION["aviso_admin"] = [
        "tipo" => "erro",
        "texto" => "A mensagem informada não foi encontrada."
    ];
}

Como id é a chave primária, a condição pode localizar no máximo uma linha. A aplicação espera modificar exatamente uma. Zero indica que o ID não encontrou um registro; qualquer resultado diferente do esperado não deve ser tratado como sucesso.

Aula 4 — Confirmando sem repetir a alteração

Use uma mensagem temporária e redirecione

Depois do processamento, preserve o filtro permitido e transforme o POST em um novo GET:

$destino = "painel.php";

if ($assuntoRetorno !== "") {
    $destino .= "?assunto=" . rawurlencode($assuntoRetorno);
}

header("Location: " . $destino, true, 303);
exit;

O painel lê $_SESSION["aviso_admin"], remove a mensagem da sessão e a mostra uma única vez. Atualizar a página repete apenas o GET do painel, não o UPDATE.

Teste o caminho feliz e as recusas

O que você vai aprender

• Relacionar coleta, uso, retenção e descarte no ciclo de vida dos dados.
• Distinguir exclusão, arquivamento, anonimização e cópia de segurança.
• Definir uma regra de negócio antes de oferecer o botão de exclusão.
• Exigir confirmação sem confiar apenas na interface.
• Proteger a rota com autenticação, POST e token CSRF.
• Executar DELETE parametrizado com WHERE defensivo.
• Conferir a quantidade de linhas afetadas e aplicar POST–Redirect–GET.
• Testar tanto o sucesso quanto as tentativas que devem ser recusadas.

Aula 1 — Decidindo antes de apagar

Entender: o dado percorre um ciclo

A mensagem existe para permitir contato e atendimento. Quando esse trabalho termina, o negócio deve avaliar se ainda há uma finalidade legítima ou alguma obrigação que justifique a conservação. O exemplo didático não inventará um prazo universal: negócios diferentes podem ter finalidades e obrigações diferentes.

Escolha a ação correta

Backup não é botão “Desfazer” do painel. Uma exclusão na base ativa pode continuar presente em cópias temporárias de segurança até o encerramento do ciclo dessas cópias. Por isso, retenção e backup precisam de regras coerentes.

Aula 2 — Tornando a intenção inequívoca

Mostre a ação somente no momento adequado

No painel, mantenha a atualização para todos os estados, mas ofereça a exclusão apenas quando a mensagem estiver respondida. Isso reduz enganos sem substituir a validação do servidor.

<?php if ($registro["status"] === "respondida"): ?>
  <form method="post" action="excluir-mensagem.php"
        class="formulario-exclusao">
    <input type="hidden" name="csrf_token"
           value="<?= escaparPainel($csrfToken) ?>">
    <input type="hidden" name="id"
           value="<?= (int) $registro["id"] ?>">
    <input type="hidden" name="assunto_retorno"
           value="<?= escaparPainel($assunto) ?>">

    <label>
      <input type="checkbox" name="confirmacao"
             value="excluir" required>
      Confirmo a exclusão desta mensagem respondida
    </label>
    <button type="submit">Excluir mensagem</button>
  </form>
<?php endif; ?>

Aula 3 — Excluindo uma única mensagem respondida

Proteja a rota antes de tocar no banco

Crie public/admin/excluir-mensagem.php e repita as barreiras das outras ações administrativas:

iniciarSessaoSegura();
exigirAutenticacao();

if (($_SERVER["REQUEST_METHOD"] ?? "GET") !== "POST") {
    header("Allow: POST");
    http_response_code(405);
    exit("Método não permitido.");
}

if (!tokenCsrfValido($_POST["csrf_token"] ?? "")) {
    http_response_code(403);
    exit("Não foi possível confirmar a exclusão.");
}

Valide o ID e a confirmação

$id = filter_var(
    $_POST["id"] ?? "",
    FILTER_VALIDATE_INT,
    ["options" => ["min_range" => 1]]
);

$confirmacao = $_POST["confirmacao"] ?? "";
$confirmacao = is_string($confirmacao) ? $confirmacao : "";

if ($id === false || $confirmacao !== "excluir") {
    // Registre um aviso de erro e não execute DELETE.
}

Coloque a regra também no WHERE

$comando = $pdo->prepare(
    "DELETE FROM mensagens
     WHERE id = :id
       AND status = 'respondida'"
);

$comando->execute(["id" => $id]);

O ID limita a operação a uma linha. A condição do estado impede a exclusão de uma mensagem nova ou em atendimento, mesmo que alguém altere o HTML. O marcador mantém o valor externo separado da estrutura SQL.

Trate sucesso como exatamente uma linha removida

if ($comando->rowCount() === 1) {
    $_SESSION["aviso_admin"] = [
        "tipo" => "sucesso",
        "texto" => "Mensagem excluída com sucesso."
    ];
} else {
    $_SESSION["aviso_admin"] = [
        "tipo" => "erro",
        "texto" => "A mensagem não existe ou ainda não pode ser excluída."
    ];
}

Zero linhas não deve virar sucesso: o ID pode não existir ou o registro pode não estar respondido. A mensagem de retorno não revela detalhes desnecessários, mas orienta a pessoa autenticada.

Aula 4 — Comprovando que a exclusão está sob controle

Redirecione e preserve o filtro

Depois da tentativa, reconstrua somente um destino permitido e responda com 303. Atualizar o painel repetirá o GET, não a exclusão:

$destino = "painel.php";

if ($assuntoRetorno !== "") {
    $destino .= "?assunto=" . rawurlencode($assuntoRetorno);
}

header("Location: " . $destino, true, 303);
exit;

Teste o que deve funcionar e o que deve falhar

Registre uma política simples antes de automatizar

O Café Aurora deve documentar: finalidade das mensagens, responsáveis, critérios de encerramento, condições de conservação, forma de descarte e tratamento das cópias de segurança. Uma rotina automática só deve existir depois que essas decisões estiverem corretas. Automatizar uma regra errada apenas produz erros mais rapidamente.

O que você vai aprender

• Explicar regressão e o valor de uma verificação repetível.
• Distinguir teste manual, unitário, de integração e ponta a ponta.
• Organizar um teste em preparar, executar e verificar.
• Extrair acesso ao banco para uma função que possa ser chamada fora da rota.
• Criar um banco SQLite exclusivo em memória.
• Construir um pequeno executor de testes sem dependências externas.
• Usar mensagens de falha e código de saída para indicar o resultado.
• Reconhecer o que a suíte protege e o que ainda exige outros testes.

Aula 1 — Transformando uma conferência em especificação executável

Entender: clicar uma vez não prova o futuro

Um teste manual responde se um comportamento funcionou naquele momento e naquele caminho percorrido. Um teste automatizado registra entradas, ação e resultado esperado em código. Ele pode ser repetido depois de uma correção, refatoração ou nova funcionalidade.

O teste deste capítulo é de integração: usa PDO, o driver SQLite, uma tabela real e a instrução SQL de produção. Chamar qualquer teste de “unitário” apenas porque ele é automatizado esconderia dependências importantes.

Escreva o comportamento antes do mecanismo

Essas frases são regras observáveis. Detalhes como nome de variável ou quantidade de linhas da função podem mudar sem quebrar o contrato. Um bom teste protege comportamento relevante, não a aparência interna do código.

Aula 2 — Fazendo a aplicação e o teste chamarem o mesmo código

Extraia a operação da rota

Crie src/repositorio-mensagens.php. A função recebe a conexão pronta e o ID, executa a exclusão defensiva e devolve se exatamente uma linha foi removida:

<?php
function excluirMensagemRespondida(PDO $pdo, int $id): bool
{
    $comando = $pdo->prepare(
        "DELETE FROM mensagens
         WHERE id = :id
           AND status = 'respondida'"
    );

    $comando->execute(["id" => $id]);

    return $comando->rowCount() === 1;
}

A função não abre a conexão por conta própria. Quem chama decide se entregará o banco do sistema ou um banco exclusivo de teste. Essa passagem explícita da dependência torna o código mais flexível e reduz a chance de o teste tocar dados reais.

Use a função na rota existente

require_once dirname(__DIR__, 2) .
    "/src/repositorio-mensagens.php";

$pdo = conectarBanco();
$excluiu = excluirMensagemRespondida($pdo, $id);

if ($excluiu) {
    // Registre o aviso de sucesso.
} else {
    // A mensagem não existe ou não está respondida.
}

Aula 3 — Preparando um laboratório descartável

Crie um banco novo para cada teste

Em tests/exclusao-mensagem-test.php, abra sqlite::memory:. O conteúdo existirá somente naquela conexão e desaparecerá quando o processo terminar:

function criarBancoTeste(): PDO
{
    $pdo = new PDO("sqlite::memory:", null, null, [
        PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
        PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC
    ]);

    $pdo->exec(
        "CREATE TABLE mensagens (
            id INTEGER PRIMARY KEY,
            status TEXT NOT NULL
        )"
    );

    $pdo->exec(
        "INSERT INTO mensagens (id, status) VALUES
         (1, 'nova'),
         (2, 'em_atendimento'),
         (3, 'respondida'),
         (4, 'respondida')"
    );

    return $pdo;
}

Cada caso chama criarBancoTeste(). Assim, um teste não depende da ordem nem das alterações deixadas pelo anterior. O conjunto inicial conhecido é chamado de fixture.

Use preparar, executar e verificar

$pdo = criarBancoTeste();                    // Arrange

$excluiu = excluirMensagemRespondida(       // Act
    $pdo,
    3
);

verificar($excluiu,                         // Assert
    "A mensagem respondida deveria ser excluída."
);

$quantidade = (int) $pdo
    ->query("SELECT COUNT(*) FROM mensagens WHERE id = 3")
    ->fetchColumn();

verificar($quantidade === 0,
    "O registro 3 ainda está no banco."
);

A organização Arrange–Act–Assert deixa clara a preparação, a ação principal e a comprovação. Comentários podem ajudar no início, mas a estrutura e os nomes devem tornar cada etapa reconhecível.

Crie verificações que falhem com explicação

function verificar(bool $condicao, string $mensagem): void
{
    if (!$condicao) {
        throw new RuntimeException($mensagem);
    }
}

function testar(string $descricao, callable $teste): bool
{
    try {
        $teste();
        echo "[OK] $descricao" . PHP_EOL;
        return true;
    } catch (Throwable $erro) {
        echo "[FALHOU] $descricao" . PHP_EOL;
        echo "  " . $erro->getMessage() . PHP_EOL;
        return false;
    }
}

verificar() interrompe o caso quando uma expectativa não é atendida. testar() captura a falha, mostra o comportamento afetado e permite que os próximos casos também sejam executados.

Aula 4 — Executando, provocando falha e interpretando o resultado

Rode toda a suíte com um comando

php tests/exclusao-mensagem-test.php

A saída esperada apresenta quatro casos aprovados e termina com um resumo. O arquivo retorna código 0 quando tudo passa e 1 quando existe falha. Editores, scripts e futuras ferramentas de integração contínua usam esse código para decidir se a execução foi bem-sucedida.

Comprove que o teste detecta o defeito

1. Execute a suíte e confirme que todos os casos passam.
2. Temporariamente, retire AND status = 'respondida' da função.
3. Execute novamente: os casos proibidos devem falhar.
4. Restaure a condição e confirme que a suíte volta a passar.

Um teste que nunca foi visto falhar pode estar verificando a coisa errada. Essa alteração controlada demonstra que a suíte realmente vigia a regra. Não publique nem mantenha o defeito provocado.

Confira o código de saída

Entenda por que começamos sem framework

O pequeno executor torna visíveis caso, expectativa, falha, resumo e código de saída. Em projetos reais, não convém ampliar indefinidamente uma ferramenta caseira. O PHPUnit oferece organização, asserções, seleção de testes, relatórios e integração com outras ferramentas. O próximo passo será migrar esta suíte para uma ferramenta de mercado sem perder o entendimento construído aqui.

O que você vai aprender

• Explicar a diferença entre gerenciador de dependências, framework de testes e executor.
• Distinguir composer.json, composer.lock e vendor/.
• Declarar requisitos de execução e dependências exclusivas de desenvolvimento.
• Carregar o código da aplicação pelo autoload do Composer.
• Migrar os quatro casos para uma classe TestCase.
• Trocar verificações caseiras por asserções expressivas do PHPUnit.
• Configurar e executar a suíte com um comando estável.
• Selecionar um caso, provocar uma falha e interpretar o relatório.

Aula 1 — Tornando as dependências explícitas

Entender: cada arquivo responde a uma pergunta

O arquivo JSON declara a intenção; o arquivo de trava registra a resolução; a pasta vendor/ é o resultado instalado. Confundir esses papéis produz instalações enormes ou diferentes entre computadores.

Confira o ambiente

php -v
composer --version
php -m | findstr /I "PDO sqlite mbstring xml"

Este módulo usa PHP 8.5. O PHPUnit 13 exige PHP 8.4 ou superior, portanto as versões são compatíveis. No Linux ou macOS, substitua findstr por grep -Ei.

Aula 2 — Descrevendo o projeto com Composer

Experimentar: crie composer.json

{
  "name": "mundobitbyte/cafe-aurora-web2",
  "description": "Projeto didático do curso de Programação Web II",
  "type": "project",
  "require": {
    "php": "^8.5",
    "ext-pdo": "*",
    "ext-pdo_sqlite": "*"
  },
  "require-dev": {
    "phpunit/phpunit": "^13.0"
  },
  "autoload": {
    "files": [
      "src/repositorio-mensagens.php"
    ]
  },
  "scripts": {
    "test": "phpunit --testdox"
  },
  "config": {
    "sort-packages": true
  }
}

require descreve o que a aplicação precisa para funcionar. require-dev contém ferramentas usadas para desenvolver e verificar o projeto. O PHPUnit não é necessário para servir as páginas ao visitante, por isso pertence ao segundo grupo.

As entradas ext-pdo e ext-pdo_sqlite não baixam extensões do PHP. Elas fazem o Composer interromper a instalação com uma explicação quando o ambiente não possui capacidades exigidas pelo sistema.

Experimente a primeira instalação

composer validate
composer install

Como o checkpoint ainda não possui composer.lock, a primeira instalação resolve versões compatíveis, grava a trava e cria vendor/. Depois disso, mantenha o lock no controle de versão e use composer install para repetir aquelas versões. Use composer update somente quando a equipe decidir atualizar dependências e revisar a nova trava.

Aula 3 — Migrando os casos para PHPUnit

Programar: configure a descoberta da suíte

Crie phpunit.xml na raiz. O bootstrap carrega o arquivo gerado pelo Composer; a suíte procura classes de teste na pasta tests:

<?xml version="1.0" encoding="UTF-8"?>
<phpunit bootstrap="vendor/autoload.php"
         colors="true"
         cacheDirectory=".phpunit.cache">
  <testsuites>
    <testsuite name="integração">
      <directory>tests</directory>
    </testsuite>
  </testsuites>
</phpunit>

Transforme funções em métodos de teste

<?php
declare(strict_types=1);

use PHPUnit\Framework\TestCase;

final class ExclusaoMensagemTest extends TestCase
{
    public function testExcluiUmaMensagemRespondida(): void
    {
        $pdo = $this->criarBancoTeste();

        $excluiu = excluirMensagemRespondida($pdo, 3);

        self::assertTrue($excluiu);
        self::assertSame(0, $this->quantidadeMensagem($pdo, 3));
    }

    public function testNaoExcluiUmaMensagemNova(): void
    {
        $pdo = $this->criarBancoTeste();

        $excluiu = excluirMensagemRespondida($pdo, 1);

        self::assertFalse($excluiu);
        self::assertSame(1, $this->quantidadeMensagem($pdo, 1));
    }
}

A classe herda infraestrutura de TestCase. Métodos públicos iniciados por test são descobertos como casos. assertTrue(), assertFalse() e assertSame() registram expectativas e produzem relatórios sem as funções verificar() e testar().

Aula 4 — Executando uma rotina profissional

Aplicar: rode toda a suíte

composer test

O script chama a cópia do PHPUnit instalada no próprio projeto e ativa o relatório TestDox. Assim, todos usam a dependência declarada pelo projeto, sem exigir uma instalação global do framework.

Isole um comportamento durante a investigação

vendor\bin\phpunit --filter testNaoExcluiUmaMensagemNova

No Linux ou macOS, use vendor/bin/phpunit. O filtro acelera a investigação local, mas não substitui a execução da suíte completa antes de concluir a mudança.

Pratique vermelho, verde e refatoração

1. Rode composer test e confirme os quatro casos verdes.
2. Retire temporariamente a condição status = 'respondida' do repositório.
3. Rode o caso filtrado e leia valores esperado e obtido na falha.
4. Restaure a regra e execute novamente toda a suíte.
5. Melhore nomes ou remova repetição sem mudar o comportamento; mantenha a suíte verde.

O que você vai aprender

• Distinguir código concluído, versão candidata e sistema entregue.
• Explicar por que o GitHub Pages publica o curso, mas não executa o projeto PHP.
• Verificar versão, extensões e permissão de gravação antes da implantação.
• Separar o caminho do banco do código por variável de ambiente.
• Diferenciar apresentação de erros em desenvolvimento e registro em produção.
• Criar um backup consistente e planejar um ensaio de restauração.
• Executar um teste de aceitação do fluxo público e administrativo.
• Registrar evidências, responsáveis, limites e próximos passos.

Aula 1 — Definindo o que significa entregar

Entender: endereço publicado não garante sistema executado

O projeto baixado precisa de processamento no servidor. A hospedagem escolhida deve permitir definir a pasta public/ como raiz acessível, gravar o SQLite fora dela, manter os dados entre implantações e oferecer HTTPS. Se um desses requisitos não puder ser comprovado, o ambiente ainda não foi aceito.

Transforme expectativa em critério observável

Uma frase como “está tudo certo” não é evidência. Um critério de aceite contém ação, resultado esperado e registro da conferência. A versão que passará por esses critérios é a candidata à entrega.

Aula 2 — Verificando o ambiente antes do usuário

Experimentar: execute uma inspeção repetível

O checkpoint acrescenta src/verificar-ambiente.php. Ele confere PHP 8.5, PDO, o driver SQLite e a pasta que receberá o banco:

$verificacoes = [
    "PHP 8.5 ou superior" =>
        version_compare(PHP_VERSION, "8.5.0", ">="),
    "extensão PDO ativa" => extension_loaded("pdo"),
    "driver pdo_sqlite ativo" => extension_loaded("pdo_sqlite"),
    "pasta do banco existente" => is_dir($pastaBanco),
    "pasta do banco gravável" =>
        is_dir($pastaBanco) && is_writable($pastaBanco)
];

composer check

O comando executa primeiro a inspeção do ambiente e depois a suíte PHPUnit. Ele retorna código diferente de zero diante de uma falha, o que permite interromper uma entrega inadequada. Ainda assim, uma verificação técnica não substitui a navegação real.

Não use o servidor de desenvolvimento em produção

php -S localhost:8000 -t public continua útil no laboratório. O próprio Manual do PHP alerta que o servidor embutido não é um servidor completo e não deve ser usado em rede pública. O ambiente final precisa de um servidor Web mantido para produção.

Aula 3 — Separando dados e preparando recuperação

Programar: permita configurar o caminho do banco

function caminhoBanco(): string
{
    $caminhoConfigurado = getenv("CAFE_AURORA_DB_PATH");

    if (is_string($caminhoConfigurado) &&
        trim($caminhoConfigurado) !== "") {
        return trim($caminhoConfigurado);
    }

    return dirname(__DIR__) .
        "/dados/cafe-aurora.sqlite";
}

Sem configuração, o laboratório continua usando dados/cafe-aurora.sqlite. No servidor, CAFE_AURORA_DB_PATH pode apontar para o armazenamento persistente definido pela hospedagem. O valor não precisa ser gravado no repositório.

Crie uma cópia consistente do SQLite

$pdo = conectarBanco();
$destinoSql = $pdo->quote($destino);

if ($destinoSql === false) {
    throw new RuntimeException(
        "O destino do backup não pôde ser preparado."
    );
}

$pdo->exec("VACUUM INTO $destinoSql");

composer backup

VACUUM INTO produz uma cópia consistente do banco em outro arquivo. O script confirma origem, destino e tamanho antes de declarar sucesso. Por padrão, usa backups/; no servidor, CAFE_AURORA_BACKUP_DIR pode indicar outra pasta protegida e persistente. Esses arquivos são ignorados pelo Git porque podem conter dados pessoais.

Aula 4 — Aplicando o ensaio de entrega

Aplicar: percorra o sistema como visitante e proprietária

Separe preparação, implantação e aceitação

1. Em desenvolvimento, execute composer install e composer check.
2. Crie um backup e registre qual versão está sendo entregue.
3. No servidor, defina a raiz public/, o caminho persistente do banco, HTTPS, erros e logs.
4. Instale com composer install --no-dev --optimize-autoloader.
5. Pelo terminal do servidor, verifique o ambiente, inicialize o banco e crie uma credencial exclusiva.
6. No endereço final, execute o teste de aceitação e registre problemas encontrados.
7. Entregue instruções, responsáveis, frequência de backup e limites conhecidos.

A rota de exclusão também passa a carregar o repositório por vendor/autoload.php. Assim, a instalação declarada pelo Composer deixa de ser apenas uma convenção dos testes e integra a execução da aplicação.