cybercore-systems/workbloomerp-api
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: implement JWT-based authentication system with repository, service, and middleware layers

Browse Source
This commit is contained in:
claudecio
2026-09-09 20:02:55 -03:00
parent f6d7d42f10
commit 14b85d28a1
11 changed files with 975 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files
bin/create-user.php
+88
View File
@@ -0,0 +1,88 @@
<?php
require_once __DIR__ . '/../vendor/autoload.php';
use Dotenv\Dotenv;
use Ramsey\Uuid\Uuid;
use KrothiumAPI\Database\DBManager;
$dotenv = Dotenv::createImmutable(__DIR__ . '/..');
$dotenv->load();
$db = DBManager::getConnection();
$nome = $argv[1] ?? 'Administrador Workbloom';
$email = $argv[2] ?? 'admin@workbloom.com.br';
$usuario = $argv[3] ?? 'admin';
$senha = $argv[4] ?? 'Admin@123456';
echo "=== Criação de Usuário Administrador ===\n";
echo "Nome: {$nome}\n";
echo "Email: {$email}\n";
echo "Usuário: {$usuario}\n";
// Verifica se já existe por e-mail ou nome_usuario
$existente = $db->fetchOne(
"SELECT id, uuid, email, nome_usuario FROM usuario WHERE email = :email OR nome_usuario = :usuario LIMIT 1",
['email' => $email, 'usuario' => $usuario]
);
if ($existente !== null) {
echo "Erro: Usuário já cadastrado com este e-mail ou nome de usuário (ID: {$existente['id']}).\n";
exit(1);
}
$userUuid = Uuid::uuid7()->toString();
$senhaHash = password_hash($senha, PASSWORD_ARGON2ID);
// Cria o usuário
$db->insert('usuario', [
'uuid' => $userUuid,
'nome_completo' => $nome,
'email' => $email,
'nome_usuario' => $usuario,
'senha_hash' => $senhaHash,
'ativo' => 1,
]);
$userId = (int)$db->fetchColumn(
"SELECT id FROM usuario WHERE uuid = :uuid LIMIT 1",
['uuid' => $userUuid]
);
echo "Usuário criado com sucesso! ID: {$userId}, UUID: {$userUuid}\n";
// Verifica se existe ao menos uma empresa
$empresaId = $db->fetchColumn("SELECT id FROM empresa WHERE deleted_at IS NULL LIMIT 1");
if (!$empresaId) {
echo "Nenhuma empresa cadastrada. Criando Empresa Matriz de teste...\n";
$empresaUuid = Uuid::uuid7()->toString();
$db->insert('empresa', [
'uuid' => $empresaUuid,
'tipo_estabelecimento' => 'MATRIZ',
'status' => 'ATIVO',
'nome_empresarial' => 'WORKBLOOM SISTEMAS LTDA',
'nome_fantasia' => 'Workbloom Matriz',
'cnpj' => '12345678000195',
'regime_tributario' => 1,
]);
$empresaId = (int)$db->fetchColumn(
"SELECT id FROM empresa WHERE uuid = :uuid LIMIT 1",
['uuid' => $empresaUuid]
);
echo "Empresa criada! ID: {$empresaId}, UUID: {$empresaUuid}\n";
} else {
$empresaId = (int)$empresaId;
}
// Vincula usuário à empresa como ADMIN
$db->insert('usuario_empresa', [
'usuario_id' => $userId,
'empresa_id' => $empresaId,
'perfil' => 'ADMIN',
'acesso_todas_filiais' => 1,
]);
echo "Vínculo criado na empresa ID: {$empresaId} como ADMIN!\n";
echo "Concluído com sucesso!\n";
bin/test-auth.php
+353
View File
@@ -0,0 +1,353 @@
<?php
/**
* Suíte de testes automatizados do fluxo de autenticação (Workbloom ERP).
* Executa todos os cenários requeridos com validação rigorosa de regras.
*/
require_once __DIR__ . '/../vendor/autoload.php';
use Dotenv\Dotenv;
use Ramsey\Uuid\Uuid;
use KrothiumAPI\Database\DBManager;
use WorkbloomERP\Security\JwtService;
use WorkbloomERP\Security\AuthContext;
use WorkbloomERP\Middleware\AuthMiddleware;
use WorkbloomERP\Module\Auth\DTO\LoginDTO;
use WorkbloomERP\Module\Auth\Repository\AuthRepository;
use WorkbloomERP\Module\Auth\Service\AuthService;
$dotenv = Dotenv::createImmutable(__DIR__ . '/..');
$dotenv->load();
$db = DBManager::getConnection();
$repo = new AuthRepository($db);
$jwt = new JwtService();
$service = new AuthService($repo, $jwt);
$passed = 0;
$failed = 0;
function assertTest(string $title, bool $condition, ?string $detail = null): void {
global $passed, $failed;
if ($condition) {
echo " [PASS] {$title}\n";
$passed++;
} else {
echo " [FAIL] {$title}" . ($detail ? " - {$detail}" : "") . "\n";
$failed++;
}
}
echo "\n=======================================================\n";
echo " INICIANDO BATERIA DE TESTES DE AUTENTICAÇÃO\n";
echo "=======================================================\n\n";
// ---------------------------------------------------------------------------
// 1. Login com e-mail válido
// ---------------------------------------------------------------------------
echo "Cenário 1: Login com e-mail válido\n";
try {
$dto = LoginDTO::fromArray(['login' => 'admin@workbloom.com.br', 'senha' => 'Admin@123456']);
$res = $service->login($dto);
assertTest("Geração do token JWT", !empty($res['token']));
assertTest("Tipo do token é Bearer", $res['token_type'] === 'Bearer');
assertTest("Tempo de expiração retornado", $res['expires_in'] > 0);
assertTest("Dados do usuário presentes", isset($res['usuario']['email']) && $res['usuario']['email'] === 'admin@workbloom.com.br');
assertTest("UUID presente no usuário", !empty($res['usuario']['uuid']));
assertTest("ID numérico NÃO exposto no usuário", !isset($res['usuario']['id']));
assertTest("Senha hash NÃO exposta no retorno", !isset($res['usuario']['senha_hash']));
assertTest("Empresas vinculadas presentes", is_array($res['empresas']) && count($res['empresas']) >= 1);
assertTest("UUID presente na empresa", !empty($res['empresas'][0]['uuid']));
assertTest("ID numérico NÃO exposto na empresa", !isset($res['empresas'][0]['id']));
assertTest("Perfil ADMIN identificado na empresa", $res['empresas'][0]['perfil'] === 'ADMIN');
assertTest("Flag de acesso a todas as filiais presente", isset($res['empresas'][0]['acesso_todas_filiais']));
} catch (Throwable $e) {
assertTest("Execução do login por e-mail", false, $e->getMessage());
}
// ---------------------------------------------------------------------------
// 2. Login com nome de usuário válido
// ---------------------------------------------------------------------------
echo "\nCenário 2: Login com nome de usuário válido\n";
try {
$dto = LoginDTO::fromArray(['login' => 'admin', 'senha' => 'Admin@123456']);
$res = $service->login($dto);
assertTest("Login por username autenticado com sucesso", !empty($res['token']));
assertTest("ID do usuário consistente", $res['usuario']['nome_usuario'] === 'admin');
} catch (Throwable $e) {
assertTest("Execução do login por username", false, $e->getMessage());
}
// ---------------------------------------------------------------------------
// 3. Login com senha inválida
// ---------------------------------------------------------------------------
echo "\nCenário 3: Login com senha inválida\n";
try {
$dto = LoginDTO::fromArray(['login' => 'admin', 'senha' => 'SenhaIncorreta@999']);
$service->login($dto);
assertTest("Bloqueio de senha incorreta", false, "Deveria ter lançado RuntimeException");
} catch (RuntimeException $e) {
assertTest("Rejeitado com código 401", $e->getCode() === 401);
assertTest("Mensagem genérica de credenciais inválidas", $e->getMessage() === 'Credenciais inválidas.');
} catch (Throwable $e) {
assertTest("Bloqueio de senha incorreta", false, $e->getMessage());
}
// ---------------------------------------------------------------------------
// 4. Login com usuário inexistente (prevenção contra enumeração)
// ---------------------------------------------------------------------------
echo "\nCenário 4: Tentativa com usuário inexistente\n";
try {
$dto = LoginDTO::fromArray(['login' => 'usuario_fantasma_xyz@workbloom.com.br', 'senha' => 'Admin@123456']);
$service->login($dto);
assertTest("Bloqueio de usuário inexistente", false, "Deveria ter lançado RuntimeException");
} catch (RuntimeException $e) {
assertTest("Rejeitado com código 401", $e->getCode() === 401);
assertTest("Mesma mensagem genérica do erro de senha (anti-enumeração)", $e->getMessage() === 'Credenciais inválidas.');
} catch (Throwable $e) {
assertTest("Bloqueio de usuário inexistente", false, $e->getMessage());
}
// ---------------------------------------------------------------------------
// Criação temporária de usuários de teste para cenários avançados
// ---------------------------------------------------------------------------
$testUserUuidInativo = Uuid::uuid7()->toString();
$testUserUuidDeletado = Uuid::uuid7()->toString();
$testUserUuidSemEmpresa = Uuid::uuid7()->toString();
$testUserUuidMultiEmpresa = Uuid::uuid7()->toString();
$senhaHashPadrao = password_hash('Teste@123456', PASSWORD_ARGON2ID);
// 5. Usuário inativo
$db->insert('usuario', [
'uuid' => $testUserUuidInativo,
'nome_completo' => 'Usuário Inativo Teste',
'email' => 'inativo@workbloom.com.br',
'nome_usuario' => 'user_inativo',
'senha_hash' => $senhaHashPadrao,
'ativo' => 0,
]);
$idInativo = (int)$db->fetchColumn("SELECT id FROM usuario WHERE uuid = :uuid LIMIT 1", ['uuid' => $testUserUuidInativo]);
// 6. Usuário logicamente excluído (deleted_at)
$db->insert('usuario', [
'uuid' => $testUserUuidDeletado,
'nome_completo' => 'Usuário Deletado Teste',
'email' => 'deletado@workbloom.com.br',
'nome_usuario' => 'user_deletado',
'senha_hash' => $senhaHashPadrao,
'ativo' => 1,
]);
$idDeletado = (int)$db->fetchColumn("SELECT id FROM usuario WHERE uuid = :uuid LIMIT 1", ['uuid' => $testUserUuidDeletado]);
$db->execute("UPDATE usuario SET deleted_at = CURRENT_TIMESTAMP WHERE id = :id", ['id' => $idDeletado]);
// 7. Usuário sem vínculo com empresa
$db->insert('usuario', [
'uuid' => $testUserUuidSemEmpresa,
'nome_completo' => 'Usuário Sem Empresa',
'email' => 'semempresa@workbloom.com.br',
'nome_usuario' => 'user_semempresa',
'senha_hash' => $senhaHashPadrao,
'ativo' => 1,
]);
$idSemEmpresa = (int)$db->fetchColumn("SELECT id FROM usuario WHERE uuid = :uuid LIMIT 1", ['uuid' => $testUserUuidSemEmpresa]);
// 8. Usuário multiempresa com perfis distintos
$db->insert('usuario', [
'uuid' => $testUserUuidMultiEmpresa,
'nome_completo' => 'Usuário Multiempresa',
'email' => 'multiempresa@workbloom.com.br',
'nome_usuario' => 'user_multiempresa',
'senha_hash' => $senhaHashPadrao,
'ativo' => 1,
]);
$idMultiEmpresa = (int)$db->fetchColumn("SELECT id FROM usuario WHERE uuid = :uuid LIMIT 1", ['uuid' => $testUserUuidMultiEmpresa]);
// Cria 2 empresas adicionais de teste
$empresaUuid1 = Uuid::uuid7()->toString();
$empresaUuid2 = Uuid::uuid7()->toString();
$db->insert('empresa', [
'uuid' => $empresaUuid1,
'tipo_estabelecimento' => 'MATRIZ',
'status' => 'ATIVO',
'nome_empresarial' => 'EMPRESA ALFA LTDA',
'nome_fantasia' => 'Alfa Matriz',
'cnpj' => '11111111000101',
'regime_tributario' => 1,
]);
$idEmpresaAlfa = (int)$db->fetchColumn("SELECT id FROM empresa WHERE uuid = :uuid LIMIT 1", ['uuid' => $empresaUuid1]);
$db->insert('empresa', [
'uuid' => $empresaUuid2,
'tipo_estabelecimento' => 'FILIAL',
'status' => 'ATIVO',
'nome_empresarial' => 'EMPRESA BETA FILIAL LTDA',
'nome_fantasia' => 'Beta Filial',
'cnpj' => '11111111000202',
'regime_tributario' => 1,
]);
$idEmpresaBeta = (int)$db->fetchColumn("SELECT id FROM empresa WHERE uuid = :uuid LIMIT 1", ['uuid' => $empresaUuid2]);
// Vincula usuário multiempresa às 2 empresas com perfis diferentes
$db->insert('usuario_empresa', [
'usuario_id' => $idMultiEmpresa,
'empresa_id' => $idEmpresaAlfa,
'perfil' => 'ADMIN',
'acesso_todas_filiais' => 1,
]);
$db->insert('usuario_empresa', [
'usuario_id' => $idMultiEmpresa,
'empresa_id' => $idEmpresaBeta,
'perfil' => 'EMISSOR',
'acesso_todas_filiais' => 0,
]);
try {
// ---------------------------------------------------------------------------
// Cenário 5: Tentativa com usuário inativo
// ---------------------------------------------------------------------------
echo "\nCenário 5: Tentativa com usuário inativo (ativo = false)\n";
try {
$dto = LoginDTO::fromArray(['login' => 'inativo@workbloom.com.br', 'senha' => 'Teste@123456']);
$service->login($dto);
assertTest("Bloqueio de usuário inativo", false, "Deveria ter lançado RuntimeException 403");
} catch (RuntimeException $e) {
assertTest("Rejeitado com código 403", $e->getCode() === 403);
assertTest("Mensagem indica usuário inativo", str_contains($e->getMessage(), 'inativo'));
}
// ---------------------------------------------------------------------------
// Cenário 6: Tentativa com usuário com deleted_at preenchido
// ---------------------------------------------------------------------------
echo "\nCenário 6: Tentativa com usuário excluído (deleted_at preenchido)\n";
try {
$dto = LoginDTO::fromArray(['login' => 'deletado@workbloom.com.br', 'senha' => 'Teste@123456']);
$service->login($dto);
assertTest("Bloqueio de usuário excluído", false, "Deveria ter lançado RuntimeException 401");
} catch (RuntimeException $e) {
assertTest("Rejeitado como não encontrado (401)", $e->getCode() === 401);
assertTest("Mensagem genérica de credenciais inválidas", $e->getMessage() === 'Credenciais inválidas.');
}
// ---------------------------------------------------------------------------
// Cenário 7: Usuário sem vínculo com empresa
// ---------------------------------------------------------------------------
echo "\nCenário 7: Usuário sem vínculo com empresa\n";
try {
$dto = LoginDTO::fromArray(['login' => 'semempresa@workbloom.com.br', 'senha' => 'Teste@123456']);
$res = $service->login($dto);
assertTest("Login efetuado mesmo sem empresa vinculada", !empty($res['token']));
assertTest("Lista de empresas vazia", is_array($res['empresas']) && count($res['empresas']) === 0);
} catch (Throwable $e) {
assertTest("Login sem empresa", false, $e->getMessage());
}
// ---------------------------------------------------------------------------
// Cenário 8: Usuário multiempresa com múltiplos perfis
// ---------------------------------------------------------------------------
echo "\nCenário 8: Usuário com múltiplas empresas e perfis distintos\n";
try {
$dto = LoginDTO::fromArray(['login' => 'multiempresa@workbloom.com.br', 'senha' => 'Teste@123456']);
$res = $service->login($dto);
assertTest("Autenticação com sucesso", !empty($res['token']));
assertTest("Exatamente 2 empresas vinculadas", count($res['empresas']) === 2);
$perfilMap = [];
$filiaisMap = [];
foreach ($res['empresas'] as $emp) {
$perfilMap[$emp['nome_fantasia']] = $emp['perfil'];
$filiaisMap[$emp['nome_fantasia']] = (bool)$emp['acesso_todas_filiais'];
}
assertTest("Perfil ADMIN na Empresa Alfa", ($perfilMap['Alfa Matriz'] ?? null) === 'ADMIN');
assertTest("Flag todas as filiais = true na Empresa Alfa", ($filiaisMap['Alfa Matriz'] ?? null) === true);
assertTest("Perfil EMISSOR na Empresa Beta", ($perfilMap['Beta Filial'] ?? null) === 'EMISSOR');
assertTest("Flag todas as filiais = false na Empresa Beta", ($filiaisMap['Beta Filial'] ?? null) === false);
} catch (Throwable $e) {
assertTest("Multiempresa", false, $e->getMessage());
}
// ---------------------------------------------------------------------------
// Cenário 9: Validação do Token JWT e Middleware
// ---------------------------------------------------------------------------
echo "\nCenário 9: Validação do Token JWT e Middleware de Proteção\n";
// Token forjado / adulterado
try {
$jwt->validateToken('token.invalido.falso');
assertTest("Rejeição de token adulterado", false, "Deveria ter lançado RuntimeException");
} catch (RuntimeException $e) {
assertTest("Token forjado rejeitado com código 401", $e->getCode() === 401);
}
// Token expirado
try {
$expiredJwt = new JwtService(expiresIn: -10);
$expiredData = $expiredJwt->generateToken(['id' => 1, 'sub' => 'uuid-teste']);
$jwt->validateToken($expiredData['token']);
assertTest("Rejeição de token expirado", false, "Deveria ter lançado RuntimeException");
} catch (RuntimeException $e) {
assertTest("Token expirado rejeitado com código 401", $e->getCode() === 401);
}
// Middleware sem header
unset($_SERVER['HTTP_AUTHORIZATION']);
$middleware = new AuthMiddleware($jwt);
$midRes = $middleware->handle();
assertTest("Middleware bloqueia requisição sem token", is_array($midRes) && ($midRes['block'] ?? false) === true);
assertTest("Código retornado pelo middleware é 401", ($midRes['response_code'] ?? null) === 401);
// Middleware com token válido
$tokenValido = $res['token'];
$_SERVER['HTTP_AUTHORIZATION'] = "Bearer {$tokenValido}";
AuthContext::clear();
$midResValido = $middleware->handle();
assertTest("Middleware aceita requisição com Bearer Token válido", $midResValido === true);
assertTest("AuthContext populado com o UUID do usuário", AuthContext::getUserUuid() === $testUserUuidMultiEmpresa);
// ---------------------------------------------------------------------------
// Cenário 10: Consulta ao Perfil (endpoint me / getProfile)
// ---------------------------------------------------------------------------
echo "\nCenário 10: Consulta ao Perfil do usuário autenticado (GET /api/v1/auth/me)\n";
try {
$profile = $service->getProfile(AuthContext::getUserUuid());
assertTest("Perfil recuperado com sucesso via UUID", !empty($profile['usuario']['uuid']));
assertTest("ID numérico NÃO exposto no perfil do usuário", !isset($profile['usuario']['id']));
assertTest("Nome completo presente", $profile['usuario']['nome_completo'] === 'Usuário Multiempresa');
assertTest("Senha hash NÃO exposta no perfil", !isset($profile['usuario']['senha_hash']));
assertTest("Lista de empresas presente no perfil", count($profile['empresas']) === 2);
assertTest("ID numérico NÃO exposto nas empresas do perfil", !isset($profile['empresas'][0]['id']));
assertTest("UUID presente nas empresas do perfil", !empty($profile['empresas'][0]['uuid']));
} catch (Throwable $e) {
assertTest("Consulta de perfil", false, $e->getMessage());
}
} finally {
// Limpeza dos dados temporários criados nos testes
$db->execute("DELETE FROM usuario_empresa WHERE usuario_id IN (:u1, :u2, :u3, :u4)", [
'u1' => $idInativo,
'u2' => $idDeletado,
'u3' => $idSemEmpresa,
'u4' => $idMultiEmpresa,
]);
$db->execute("DELETE FROM usuario WHERE id IN (:u1, :u2, :u3, :u4)", [
'u1' => $idInativo,
'u2' => $idDeletado,
'u3' => $idSemEmpresa,
'u4' => $idMultiEmpresa,
]);
$db->execute("DELETE FROM empresa WHERE id IN (:e1, :e2)", [
'e1' => $idEmpresaAlfa,
'e2' => $idEmpresaBeta,
]);
unset($_SERVER['HTTP_AUTHORIZATION']);
AuthContext::clear();
}
echo "\n=======================================================\n";
echo " RESULTADO DOS TESTES: {$passed} passaram, {$failed} falharam\n";
echo "=======================================================\n\n";
if ($failed > 0) {
exit(1);
}