Documentação do Core — SysFramework

Classe Core\Response

A classe Response é responsável por gerenciar as respostas HTTP enviadas pelo servidor. Ela define o status code, adiciona cabeçalhos personalizados, envia o conteúdo da resposta (como HTML ou JSON) e realiza redirecionamentos quando necessário.

📁 Namespace

namespace Core;

🧩 Atributos

• protected int $statusCode = 200; — Código de status HTTP padrão (200 OK).
• protected array $headers = []; — Armazena os cabeçalhos (headers) da resposta.

⚙️ Métodos

setStatusCode(int $code)

Define o código de status HTTP da resposta. Exemplo: 200 (OK), 404 (Not Found), 500 (Internal Server Error).

$response->setStatusCode(404);

addHeader(string $name, string $value)

Adiciona um cabeçalho (header) personalizado à resposta.

$response->addHeader('Content-Type', 'application/json');

send($content)

Envia todos os cabeçalhos definidos e exibe o conteúdo fornecido (geralmente HTML, texto ou JSON).

$response->setContentType('text/html')
         ->setStatusCode(200)
         ->send('<h1>Página carregada com sucesso!</h1>');
    

redirect($url)

Redireciona o cliente para outra URL com o código de status 302 (Found).

$response->redirect('/login');

setContentType($type = 'text/html')

Define o tipo de conteúdo da resposta. Exemplo: text/html, application/json, etc.

$response->setContentType('application/json');

💡 Exemplo Prático

use Core\Response;

$response = new Response();

// Envia resposta HTML simples
$response->setStatusCode(200)
         ->setContentType('text/html')
         ->send('<h1>Bem-vindo ao SysFramework!</h1>');

// Redireciona para outra rota
//$response->redirect('/home');
    

🧠 Observações

• Os métodos setStatusCode() e addHeader() retornam a própria instância da classe (padrão Fluent Interface).
• O método redirect() encerra imediatamente a execução do script.
• É possível combinar o Response com o Request para criar controladores RESTful.

Classe Core\Security

A classe Security fornece um conjunto de métodos estáticos para aumentar a segurança das aplicações desenvolvidas com o SysFramework. Ela protege contra ataques comuns como Cross-Site Scripting (XSS), injeção SQL e requisições forjadas (CSRF).

📁 Namespace

namespace Core;

🧰 Métodos

sanitize(string $value)

Remove todas as tags HTML e converte caracteres especiais para entidades seguras. Ideal para limpar entradas de formulários antes de armazenar ou exibir.

$nome = "<script>alert('XSS')</script>";
$seguro = Security::sanitize($nome); 
// Resultado: alert('XSS') — sem tags HTML
    

escapeSql(string $value)

Sanitiza uma string contra injeções SQL. No entanto, o uso recomendado é de prepared statements em vez de escaping manual.

// Evite concatenar valores diretamente em queries SQL.
// Use sempre prepared statements com PDO.
$query = $pdo->prepare("SELECT * FROM usuarios WHERE nome = ?");
$query->execute([$nome]);
    

generateCsrfToken()

Gera e armazena um token CSRF na sessão, usado para proteger formulários contra envios maliciosos externos.

$token = Security::generateCsrfToken();
echo '<input type="hidden" name="csrf_token" value="' . $token . '">';
    

validateCsrfToken(string $token)

Valida o token CSRF enviado em um formulário comparando-o com o valor armazenado na sessão.

if (!Security::validateCsrfToken($_POST['csrf_token'])) {
    die('Token CSRF inválido!');
}
    

escapeHtml(string $value)

Escapa caracteres HTML perigosos, prevenindo ataques de XSS. Deve ser utilizado sempre que dados do usuário forem exibidos na interface.

echo Security::escapeHtml($comentario);
// Exemplo: converte <script> em &lt;script&gt;
    

validateUrl(string $url)

Verifica se uma string é uma URL válida usando filter_var().

if (!Security::validateUrl($url)) {
    echo "URL inválida!";
}
    

💡 Exemplo Prático

use Core\Security;

session_start();

// Gera o token CSRF para o formulário
$csrfToken = Security::generateCsrfToken();

// Exibe o formulário protegido
echo '<form method="post">';
echo '<input type="hidden" name="csrf_token" value="' . $csrfToken . '">';
echo '<input type="text" name="nome">';
echo '<button type="submit">Enviar</button>';
echo '</form>';

// Valida a submissão
if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    if (!Security::validateCsrfToken($_POST['csrf_token'])) {
        die('Falha de segurança: token CSRF inválido!');
    }
    echo 'Token válido e dados processados com segurança.';
}
    

🧠 Boas Práticas

• Sempre sanitize e escape dados vindos do usuário antes de exibir na página.
• Use generateCsrfToken() e validateCsrfToken() em todos os formulários POST.
• Evite usar escapeSql(); prefira prepared statements do PDO ou MySQLi.
• Combine o uso desta classe com Request e Response para segurança completa.

Classe Core\SysCli

A classe SysCli oferece uma forma segura e estruturada de executar comandos de terminal (Command Line Interface) a partir do SysFramework. Ela foi projetada para prevenir falhas de segurança, evitando injeções de comando e exposição de credenciais sensíveis.

📁 Namespace

namespace Core;

🧩 Visão Geral

• Executa comandos de terminal de forma segura com escapeshellarg().
• Permite o controle de saída e erros através de proc_open().
• Inclui funções utilitárias para operações CLI específicas como mysqldump e servidor PHP embutido.

🧠 Propriedades

• protected array $commands — lista interna de comandos registrados (reservada para expansões futuras).

⚙️ Métodos

protected runShellCommand(string $cmd, array $args = []): array

Executa um comando de forma segura, escapando todos os argumentos e capturando o código de status, a saída e o erro. Este é o método interno usado por todos os outros métodos públicos.

use Core\SysCli;

$cli = new SysCli();
$result = $cli->execCommand('ls', ['-la']);

echo "Comando: " . $result['cmd'] . PHP_EOL;
echo "Saída: " . $result['output'] . PHP_EOL;
echo "Erro: " . $result['error'] . PHP_EOL;
echo "Status: " . $result['status'];
    

mysqldump(array $dbConfig, string $dumpFile): array

Realiza um mysqldump de forma segura, sem expor senhas na linha de comando. Cria temporariamente um arquivo de configuração protegido com as credenciais, executa o comando e o remove ao final.

$dbConfig = [
    'host' => 'localhost',
    'user' => 'root',
    'password' => 'senhaSegura123',
    'database' => 'meu_banco'
];

$cli = new SysCli();
$result = $cli->mysqldump($dbConfig, '/backups/meu_banco.sql');

if ($result['status'] === 0) {
    echo "Backup realizado com sucesso!";
} else {
    echo "Erro no backup: " . $result['error'];
}
    

serve(string $host = '127.0.0.1', int $port = 8000, string $docroot = 'public'): array

Inicia o servidor embutido do PHP apontando para o diretório especificado. Útil em ambiente de desenvolvimento para testes rápidos de aplicações.

$cli = new SysCli();
$cli->serve('0.0.0.0', 8080, 'public');
    

execCommand(string $command, array $args = []): array

Executa um comando genérico no terminal, utilizando internamente runShellCommand(). Todos os argumentos são automaticamente escapados para segurança.

$cli = new SysCli();
$result = $cli->execCommand('ping', ['-c', '4', 'google.com']);
echo $result['output'];
    

💡 Exemplo Prático

use Core\SysCli;

$cli = new SysCli();

// Rodar comando simples
echo "<pre>";
print_r($cli->execCommand('whoami'));
echo "</pre>";

// Iniciar servidor PHP local
$cli->serve('127.0.0.1', 9000, 'public');

// Realizar dump de banco de dados de forma segura
$config = [
    'host' => 'localhost',
    'user' => 'root',
    'password' => '123456',
    'database' => 'sysdb'
];
print_r($cli->mysqldump($config, '/tmp/sysdb.sql'));
    

🧱 Estrutura de Retorno

Todos os métodos de execução retornam um array com as seguintes chaves:

• status → Código de retorno do processo (0 = sucesso).
• output → Saída padrão do comando.
• error → Saída de erro, caso ocorra.
• cmd → Comando completo executado.

⚠️ Cuidados e Boas Práticas

• Nunca insira valores dinâmicos sem antes escapar — use sempre os argumentos no array.
• Evite expor senhas ou credenciais diretamente na linha de comando.
• Use o método mysqldump() para exportar bancos de forma segura.
• Prefira executar comandos dentro de usuários limitados e não como root.

Arquivo /config/bootsrap.php

O arquivo /config/bootsrap.php é o ponto de entrada principal do SysFramework. Ele inicializa o ambiente do framework, carrega configurações, rotas, middlewares, instâncias de Request e Response, e resolve as requisições HTTP recebidas.

📁 Namespace

Sem namespace (arquivo global de configuração)

🧩 Funcionalidades Principais

• Inicializa a sessão PHP (session_start()).
• Carrega arquivos auxiliares e de configuração: helpers.php, paths.php, loadenv.php, settings.php.
• Aplica middleware de sanitização para proteger dados de entrada.
• Carrega rotas do arquivo routes/web.php.
• Instancia objetos essenciais: Request, Response, SysTE, SysLogger, serviços do aplicativo.
• Resolve a requisição atual via SysRouter::resolve().

⚙️ Passo a Passo Interno

Inicialização da sessão

if (!isset($_SESSION)) {
    session_start();
}

Garante que a sessão esteja ativa, necessária para autenticação, CSRF e flash messages.

Carregamento de arquivos de configuração

require_once dirname(__DIR__) . '/config/helpers.php';
$paths = require dirname(__DIR__) . '/config/paths.php';
require_once dirname(__DIR__) . '/config/loadenv.php';
require_once dirname(__DIR__) . '/config/settings.php';
    

Middleware de sanitização

sanitizeMiddleware();

Sanitiza globalmente os dados recebidos via $_POST e $_GET para prevenir XSS e injeções.

Instância de Request e Response

$request = new \Core\Request();
$response = new \Core\Response();
    

Cria objetos que abstraem a requisição HTTP e permitem o envio de respostas.

Injeção de dependências

$dependencies = [
    new SysTE(VIEWS_PATH, VIEWSCACHE_PATH),
    new SysLogger(),
    new SomeService(),
    new AnotherService(),
    $request,
    $response
];
    

Lista de dependências que serão injetadas automaticamente nos controladores ao resolver a rota.

Resolução da rota

SysRouter::resolve($requestMethod, $requestUri, $dependencies);

O roteador encontra o controlador correspondente à URI e método HTTP, e executa o fluxo da requisição.

💡 Exemplo Prático

use Core\Request;
use Core\Response;
use Core\SysTE;
use Core\SysRouter;
use Core\SysLogger;

// Instancia objetos essenciais
$request = new Request();
$response = new Response();
$view = new SysTE(VIEWS_PATH, VIEWSCACHE_PATH);
$logger = new SysLogger();

// Define dependências do controlador
$dependencies = [$view, $logger, $request, $response];

// Resolva a rota atual
SysRouter::resolve($_SERVER['REQUEST_METHOD'], $_SERVER['REQUEST_URI'], $dependencies);
    

🧠 Observações

• O arquivo é o ponto de entrada principal do framework e deve ser incluído antes de qualquer lógica de aplicação.
• Middlewares, rotas e serviços são carregados neste arquivo, garantindo consistência em toda a aplicação.
• O framework suporta injeção automática de dependências para simplificar controladores e serviços.
• Algumas funcionalidades, como cache de rotas e banco de dados (Eloquent), estão preparadas, mas podem ser ativadas apenas quando necessário.

Arquivo /config/database.php

O arquivo /config/database.php configura a conexão com o banco de dados utilizando o Eloquent ORM do Laravel, através da classe Illuminate\Database\Capsule\Manager. Ele lê as variáveis de ambiente definidas no projeto para estabelecer a conexão e inicializar o Eloquent.

📁 Namespace

Sem namespace (arquivo global de configuração)

🧩 Funcionalidades Principais

• Configura a conexão com o banco de dados utilizando variáveis de ambiente ($_ENV).
• Suporta diferentes drivers de banco de dados: MySQL, PostgreSQL, SQLite, SQL Server, etc.
• Inicializa o Eloquent ORM para ser usado em toda a aplicação.
• Permite consultas e manipulação de dados usando ActiveRecord e Query Builder.

⚙️ Passo a Passo Interno

Instanciação do Capsule Manager

use Illuminate\Database\Capsule\Manager as Capsule;
$capsule = new Capsule;

Cria a instância do gerenciador do Eloquent.

Adição da conexão

$capsule->addConnection([
    "driver" => $_ENV['DB_CONNECTION'],
    "host" => $_ENV['DB_HOST'],
    "database" => $_ENV['DB_DATABASE'],
    "username" => $_ENV['DB_USERNAME'],
    "password" => $_ENV['DB_PASSWORD'],
    "charset" => $_ENV['DB_CHARSET'],
    "port" => $_ENV['DB_PORT'],
    "collation" => 'utf8mb4_general_ci',
    "prefix"    => '',
]);
    

Lê os parâmetros do banco de dados do arquivo .env e adiciona a conexão ao Capsule.

Inicialização do Eloquent

$capsule->setAsGlobal();
$capsule->bootEloquent();
    

Define o Eloquent como global e inicializa seus recursos, permitindo o uso do ORM em qualquer parte do projeto.

💡 Exemplo Prático

use Illuminate\Database\Capsule\Manager as Capsule;

// Obtenção da instância
$capsule = require __DIR__ . '/config/database.php';

// Consultas usando Eloquent
$users = $capsule->table('users')->get();
foreach ($users as $user) {
    echo $user->name;
}

// Ou usando Models
use App\Models\User;
$users = User::all();
    

🧠 Observações

• É necessário definir corretamente as variáveis de ambiente no .env para que a conexão funcione.
• O Capsule permite o uso do Eloquent fora do Laravel, mantendo a familiaridade com ORM.
• O retorno do arquivo é a instância do Capsule, que pode ser usada diretamente para consultas ou injeção de dependências.

Arquivo /config/functions.php

O arquivo /config/functions.php contém funções globais utilitárias utilizadas em todo o SysFramework. Ele inclui funções para sanitização, manipulação de sessões, redirecionamentos, logging, formatação de dados, criptografia, carregamento de views, autoload de classes e cálculos de datas/tempos.

📁 Namespace

Sem namespace (arquivo global de funções)

🧩 Funcionalidades Principais

• sanitizeMiddleware() — Sanitiza globalmente $_POST, $_GET e $_REQUEST.
• loadConfig($filePath) — Carrega arquivos de configuração em .php ou .ini e retorna um array associativo.
• sanitize($data) — Limpa e escapa dados de entrada para evitar XSS.
• redirect($url, $statusCode = 302) — Redireciona para outra URL com status HTTP configurável.
• logError($message, $file = 'error.log') — Registra erros em arquivo de log.
• baseUrl($path = '') — Gera URLs absolutas a partir do host atual.
• startSecureSession() — Inicializa sessões PHP seguras com cookies apenas.
• formatDate($date, $format = 'd/m/Y H:i') — Formata datas de acordo com o padrão desejado.
• loadView($viewName, $data = []) — Renderiza uma view PHP com dados passados.
• renderView($templateName, $data = []) — Renderiza templates Twig.
• encrypt($data, $key) / decrypt($data, $key) — Criptografia simétrica usando AES-256-CBC.
• autoload($className) — AutoCarregamento de classes do diretório /core.
• formatCurrency($amount, ...) — Formata valores monetários com separadores e símbolo.
• formatToTwoDecimals($number) — Formata números para duas casas decimais.
• daysBetweenDates($date1, $date2) — Calcula a diferença em dias entre duas datas.
• minutesBetweenEvents($event1, $event2) — Calcula a diferença em minutos entre dois eventos/data-hora.

💡 Exemplos Práticos

// Sanitizar dados
sanitizeMiddleware();

// Redirecionamento
redirect('/home');

// Log de erros
logError('Falha na conexão com o banco de dados.');

// Geração de URL base
echo baseUrl('assets/css/style.css');  // http://localhost/assets/css/style.css

// Formatar datas
echo formatDate('2025-08-30 14:30:00'); // 30/08/2025 14:30

// Formatar moeda
echo formatCurrency(2500); // R$ 2.500,00

// Formatar número
echo formatToTwoDecimals(45.6789); // 45.68

// Calcular diferença entre datas
echo daysBetweenDates('2025-08-01', '2025-08-30'); // 29

// Calcular minutos entre eventos
$event1 = '2025-08-30 14:00:00';
$event2 = '2025-08-30 16:30:00';
echo minutesBetweenEvents($event1, $event2); // 150
    

🧠 Observações

• As funções de sanitização são fundamentais para evitar ataques XSS e injeções.
• O arquivo é global, permitindo o uso de qualquer função sem precisar de instâncias.
• Funções de criptografia utilizam chave e vetor fixo (pode ser aprimorado para maior segurança).
• O autoload permite carregar classes do diretório /core automaticamente.
• Funções de datas e tempo retornam valores absolutos, garantindo consistência independente da ordem das datas.

Arquivo /config/helpers.php

O arquivo /config/helpers.php contém funções auxiliares globais para o SysFramework. Ele provê recursos como geração de URLs, sanitização de dados, manipulação de sessões, criptografia, helpers para views, utilitários de strings, arrays, datas, números aleatórios e segurança (CSRF).

📁 Namespace

Sem namespace (arquivo global de helpers)

🧩 Funcionalidades Principais

• unblockIp($ip) — Desbloqueia IPs previamente bloqueados por excesso de requisições.
• asset($path) — Gera URL completa para arquivos estáticos (CSS, JS, imagens).
• url($name, $params = []) — Gera URL completa baseada em nomes de rotas do SysRouter.
• sanitizeMiddleware() — Sanitiza globalmente dados recebidos via $_POST, $_GET e $_REQUEST.
• loadConfig($filePath) — Carrega arquivos de configuração PHP ou INI.
• sanitize($data) — Limpa e escapa dados de entrada.
• logError($message, $file = 'error.log') — Registra erros em arquivo de log.
• baseUrl($path = '') — Retorna URL base do site.
• startSecureSession() — Inicia sessão PHP segura com cookies apenas.
• formatDate($date, $format = 'd/m/Y H:i') — Formata datas.
• loadView($viewName, $data = []) — Renderiza views PHP.
• encrypt($data, $key) / decrypt($data, $key) — Criptografia AES-256-CBC.
• autoload($className) — AutoCarregamento de classes do diretório /core.
• formatCurrency($amount, ...) — Formata valores monetários.
• formatToTwoDecimals($number) — Formata números com duas casas decimais.
• daysBetweenDates($date1, $date2) — Calcula diferença em dias entre datas.
• minutesBetweenEvents($event1, $event2) — Calcula diferença em minutos entre datas/hora.
• generateCsrfToken() / checkCsrfToken($token) — Proteção CSRF.
• getFullUrl() — Retorna URL completa da página atual.
• redirect($url, $statusCode = 302) — Redireciona usuário.
• old($key, $default) — Recupera valores antigos de formulários.
• abort($statusCode, $message) — Lança erro HTTP e encerra.
• bcrypt($value) — Gera hash bcrypt de senha.
• str_limit($value, $limit, $end) — Limita comprimento de string.
• array_first($array, $callback) / array_last($array, $callback) — Obtém primeiro/último item de array.
• config($key, $default) — Recupera valor de configuração.
• storage_path($path) / public_path($path) / views_path($path) — Caminhos de diretórios importantes.
• dd(...$vars) — Dump and Die (depuração).
• back() — Redireciona para página anterior.
• view($view, $data) — Renderiza view PHP.
• str_slug($string, $separator) — Cria slug amigável para URLs.
• e($value) — Escapa string para HTML (XSS).
• str_random($length) — Gera string aleatória.
• optional($value) — Acessa propriedades de objetos nulos sem erro.
• blank($value) / filled($value) — Verifica se valor está vazio ou preenchido.
• route($name, $params) — Retorna URL de rota nomeada.
• now() — Retorna data/hora atual.
• generateRandomNumber($min, $max) — Gera número inteiro aleatório.

💡 Exemplos Práticos

// Gerar URL de asset
echo asset('css/style.css');

// Sanitizar dados de formulário
sanitizeMiddleware();

// Gerar token CSRF
$token = generateCsrfToken();

// Checar token CSRF
if (!checkCsrfToken($token)) abort(403, 'Token inválido');

// Redirecionar usuário
redirect('/home');

// Gerar slug
echo str_slug('Título de Exemplo'); // titulo-de-exemplo

// Gerar número aleatório entre 10 e 100
$rand = generateRandomNumber(10, 100);

// Recuperar valor antigo de formulário
$oldEmail = old('email', 'default@example.com');

// Dump and die
dd($oldEmail, $rand);
    

🧠 Observações

• Funções são globais e podem ser usadas em qualquer lugar da aplicação.
• Sanitização de inputs e tokens CSRF são essenciais para segurança.
• Funções de paths, assets e views centralizam caminhos e URLs, evitando erros de caminho absoluto.
• Helpers como optional, blank e filled ajudam a evitar erros com valores nulos.
• Funções de debug (dd) e hashing (bcrypt) facilitam desenvolvimento seguro e rápido.

Arquivo /config/loadenv.php

Este arquivo é responsável por carregar as variáveis de ambiente da aplicação a partir do arquivo .env e definir constantes globais no SysFramework. Ele utiliza a classe Core\SysEnv para leitura e acesso seguro das variáveis.

📁 Namespace

Sem namespace (arquivo global de configuração)

🧩 Funcionalidades Principais

• SysEnv::load() — Carrega as variáveis do arquivo .env para uso na aplicação.
• Define constantes globais de configuração do aplicativo:
  • APP_NAME — Nome do aplicativo (ex: SysFramework).
  • APP_ENV — Ambiente da aplicação (ex: local, production).
  • APP_KEY — Chave de aplicação usada para criptografia.
  • APP_DEBUG — Modo de depuração (true/false).
  • APP_TIMEZONE — Fuso horário da aplicação (ex: UTC).
  • APP_URL — URL base da aplicação.
  • APP_LOCALE — Local padrão (ex: utf-8).
  • BCRYPT_ROUNDS — Número de rounds para hashing Bcrypt.
• Define constantes de configuração do banco de dados:
  • DB_CONNECTION — Tipo de conexão (ex: mysql).
  • DB_CHARSET — Charset do banco de dados (ex: utf-8).
  • DB_COLLATION — Collation padrão (ex: utf8mb4_general_ci).
  • DB_PREFIX — Prefixo para tabelas.
  • DB_HOST — Host do banco (ex: 127.0.0.1).
  • DB_PORT — Porta do banco (ex: 3306).
  • DB_DATABASE — Nome do banco de dados.
  • DB_USERNAME — Usuário do banco.
  • DB_PASSWORD — Senha do banco.
• Define constantes de configuração de e-mail:
  • MAIL_TRANSPORT — Tipo de transporte (ex: smtp).
  • MAIL_HOST — Host do servidor SMTP.
  • MAIL_PORT — Porta SMTP.
  • MAIL_USERNAME — Usuário SMTP.
  • MAIL_PASSWORD — Senha SMTP.
  • MAIL_ENCRYPTION — Tipo de criptografia (ex: tls, ssl).
  • MAIL_FROM_ADDRESS — Endereço de envio padrão.
  • MAIL_FROM_NAME — Nome do remetente padrão.
  • MAILER_DSN — DSN completo para configuração do Mailer.
  • MAIL_URL — URL do serviço de e-mail, se aplicável.

💡 Observações

• As constantes definidas aqui podem ser usadas em qualquer parte da aplicação sem precisar instanciar objetos.
• Valores padrão são fornecidos caso a variável de ambiente não esteja definida no arquivo .env.
• O carregamento do .env permite que a aplicação seja facilmente configurável sem alterar o código.
• Segurança: não inclua arquivos .env no repositório público, pois contêm credenciais sensíveis.

📌 Exemplo de Uso

echo APP_NAME;       // SysFramework
echo APP_ENV;        // local
echo DB_DATABASE;    // sysframework
echo MAIL_HOST;      // sandbox.smtp.mailtrap.io
    

Arquivo /config/paths.php

Este arquivo retorna um array associativo contendo todos os caminhos principais e subdiretórios utilizados pelo SysFramework. Ele serve como referência central para localizar arquivos e pastas da aplicação.

🧩 Funcionalidades Principais

• base_path — Caminho raiz do projeto.
• Diretórios principais:
  • app_path — Pasta principal da aplicação (/app).
  • core_path — Pasta do core do framework (/core).
  • public_path — Pasta pública (/public).
  • routes_path — Pasta de rotas (/routes).
  • storage_path — Pasta de armazenamento de dados (/storage).
  • config_path — Pasta de arquivos de configuração (/config).
• Subdiretórios específicos dentro da pasta app:
  • controllers_path — Controladores (/app/Controllers).
  • models_path — Modelos (/app/Models).
  • views_path — Views (/resources/views).
  • helpers_path — Helpers (/app/Helpers).
  • events_path — Eventos (/app/Events).
  • listeners_path — Listeners (/app/Listeners).
  • middlewares_path — Middlewares (/app/Middlewares).
  • services_path — Serviços (/app/Services).
  • usecases_path — Casos de uso (/app/UseCases).
  • console_path — Scripts de console (/app/Console).
• Pastas auxiliares:
  • cache_path — Cache geral (/cache).
  • viewscache_path — Cache de views (/cache/views).
  • logs_path — Logs de erros e atividades (/logs).
  • uploads_path — Uploads de arquivos (/storage/uploads).
• Arquivos específicos:
  • webroutes_file — Arquivo principal de rotas web (/routes/web.php).
  • env_file — Arquivo de variáveis de ambiente (/.env).

💡 Observações

• Ter todos os caminhos centralizados facilita a manutenção da aplicação e evita "hardcodes" de diretórios em múltiplos lugares.
• Os caminhos são calculados dinamicamente usando dirname(__DIR__), garantindo que funcionem independentemente da estrutura do servidor.
• Para acessar qualquer caminho dentro do framework, basta usar: $paths = require 'config/paths.php'; $paths['views_path'];

📌 Exemplo de Uso

$paths = require __DIR__ . '/paths.php';
echo $paths['base_path'];        // /var/www/html/seu-projeto
echo $paths['controllers_path']; // /var/www/html/seu-projeto/app/Controllers
echo $paths['uploads_path'];     // /var/www/html/seu-projeto/storage/uploads
    

Arquivo /config/settings.php

Este arquivo é responsável por configurar variáveis globais, inicializar serviços essenciais do SysFramework e definir constantes com os caminhos do projeto, facilitando o acesso a diretórios e recursos em toda a aplicação.

🧩 Funcionalidades Principais

• Token CSRF: Gera automaticamente um token CSRF se ainda não existir na sessão, garantindo proteção contra ataques CSRF.

  if (empty($_SESSION['csrf_token'])) {
      $_SESSION['csrf_token'] = bin2hex(random_bytes(32));
  }

• Gerenciamento de Imagens: Inicializa o Intervention Image para manipulação de imagens.

  use Intervention\Image\ImageManager;
  $manager = ImageManager::gd(autoOrientation: false);

• EasyCSRF: Gera um token adicional systoken usando a biblioteca EasyCSRF para proteção adicional em formulários.

  use EasyCSRF\EasyCSRF;
  $sessionProvider = new EasyCSRF\NativeSessionProvider();
  $easyCSRF = new EasyCSRF\EasyCSRF($sessionProvider);
  $systoken = $easyCSRF->generate('systoken');
  $_SESSION['systoken'] = $systoken;

• Translator: Inicializa o serviço de tradução de mensagens do framework.

  use Core\Translator;
  $translator = new Translator('pt_br');

• Definição de Constantes de Caminhos: Todas as pastas e arquivos importantes do projeto são definidos como constantes globais, facilitando o acesso em qualquer ponto da aplicação.

  define("BASE_PATH",$paths['base_path']);
  define("APP_PATH",$paths['app_path']);
  define("CORE_PATH",$paths['core_path']);
  define("PUBLIC_PATH",$paths['public_path']);
  define("ROUTES_PATH",$paths['routes_path']);
  define("STORAGE_PATH",$paths['storage_path']);
  define("CONFIG_PATH",$paths['config_path']);
  define("CONTROLLERS_PATH",$paths['controllers_path']);
  define("MODELS_PATH",$paths['models_path']);
  define("VIEWS_PATH",$paths['views_path']);
  define("HELPERS_PATH",$paths['helpers_path']);
  define("EVENTS_PATH",$paths['events_path']);
  define("LISTENERS_PATH",$paths['listeners_path']);
  define("MIDDLEWARES_PATH",$paths['middlewares_path']);
  define("SERVICES_PATH",$paths['services_path']);
  define("USECASES_PATH",$paths['usecases_path']);
  define("CONSOLE_PATH",$paths['console_path']);
  define("CACHE_PATH",$paths['cache_path']);
  define("VIEWSCACHE_PATH",$paths['viewscache_path']);
  define("LOGS_PATH",$paths['logs_path']);
  define("UPLOADS_PATH",$paths['uploads_path']);
  define("WEBROUTES_FILE",$paths['webroutes_file']);
  define("ENV_FILE",$paths['env_file']);

💡 Observações

• O arquivo garante que sessões estejam ativas antes de inicializar tokens ou outros recursos.
• As constantes definidas podem ser usadas em qualquer lugar da aplicação, evitando duplicação de caminhos.
• O Translator facilita a internacionalização da aplicação, permitindo múltiplos idiomas.
• O EasyCSRF junto com o token padrão de sessão adiciona uma camada extra de segurança contra ataques de CSRF.

📌 Exemplo de Uso

// Usando o token CSRF
$csrf = $_SESSION['csrf_token'];

// Acessando o caminho de uploads
$uploadDir = UPLOADS_PATH;

// Traduzindo uma mensagem
echo $translator->translate('welcome');

Arquivo /public/index.php

Este é o ponto de entrada principal da aplicação (front controller) do SysFramework. Todo request HTTP passa por este arquivo, que inicializa o framework e carrega todas as dependências necessárias.

🧩 Funcionalidades Principais

• Inicialização de Sessão: Garante que a sessão do PHP esteja ativa antes de qualquer operação.

  if (!isset($_SESSION)) {
      session_start();
  }

• Exibição de Erros: Configura o PHP para exibir todos os erros e warnings, útil para desenvolvimento.

  ini_set('display_errors', 1);
  ini_set('display_startup_errors', 1);
  error_reporting(E_ALL);

• Autoloading: Carrega automaticamente todas as dependências do Composer.

  require_once dirname(__DIR__) . '/vendor/autoload.php';

• Bootstrap do Framework: Inicializa o SysFramework carregando configurações, helpers, rotas e middlewares.

  require_once dirname(__DIR__) . '/config/bootstrap.php';

💡 Observações

• O index.php deve estar dentro do diretório público (/public) para garantir segurança e separar arquivos acessíveis publicamente de arquivos internos do framework.
• Este arquivo nunca deve ser modificado diretamente para lógica de negócio; toda funcionalidade deve ser implementada via controllers, serviços e rotas.
• O carregamento do Composer e do bootstrap garante que autoloading e configuração do ambiente estejam sempre ativos antes de processar qualquer request.

📌 Fluxo de Execução

1. Inicia a sessão do usuário.
2. Ativa exibição de erros (modo desenvolvimento).
3. Carrega o autoload do Composer para dependências externas.
4. Chama o bootstrap.php para inicializar o SysFramework (helpers, rotas, env, middlewares, etc.).
5. O framework passa o request para o roteador, que dispara o controller correspondente.

Arquivo /public/robots.txt

O robots.txt é um arquivo usado para fornecer instruções aos motores de busca (como Google, Bing, etc.) sobre quais páginas ou diretórios podem ser rastreados ou indexados.

🧩 Conteúdo Atual

User-agent: *
Disallow:

💡 Explicação

• User-agent: * → Aplica a regra para todos os robôs de busca.
• Disallow: → Sem diretórios listados, o que significa que os robôs podem rastrear todas as páginas do site.

📌 Observações

• Este arquivo deve estar no diretório /public para que os motores de busca o encontrem.
• Se você quiser bloquear alguma área do site, basta adicionar o caminho após Disallow:, por exemplo Disallow: /admin/.
• O robots.txt não impede o acesso direto a páginas; ele apenas orienta os motores de busca.

Arquivo /public/.htaccess

O .htaccess é um arquivo de configuração do Apache que permite ajustar configurações específicas do servidor para o diretório onde está localizado.

🧩 Conteúdo Atual

Options All -Indexes

php_value memory_limit 768M
php_flag register_long_arrays on
#php_value post_max_size 100M
#php_value upload_max_size 64M
#php_value max_execution_time 300
#php_value max_input_time 300
#php_value upload_max_filesize 64M
#php_flag short_open_tag on
php_value date.timezone 'America/Sao_Paulo'
php_value default_charset 'UTF-8'

php_value max_file_uploads 2000

#php_value extension fileinfo.so

php_flag display_errors on
php_value error_reporting -1

#php_value session.gc_maxlifetime 1400

RewriteEngine on
RewriteCond %{SCRIPT_FILENAME} !-f
RewriteCond %{SCRIPT_FILENAME} !-d
RewriteCond %{SCRIPT_FILENAME} !-l
RewriteRule ^(.*)$ index.php/$1

💡 Explicação das Configurações

• Options All -Indexes → Desabilita a listagem de diretórios.
• php_value memory_limit 768M → Define o limite de memória do PHP para 768MB.
• php_flag register_long_arrays on → Habilita arrays antigos do PHP (ex.: $HTTP_POST_VARS).
• Configurações comentadas (#) como post_max_size, upload_max_size, max_execution_time → estão desativadas mas podem ser ajustadas conforme necessidade.
• php_value date.timezone 'America/Sao_Paulo' → Define o fuso horário padrão do PHP.
• php_value default_charset 'UTF-8' → Define a codificação padrão para UTF-8.
• php_value max_file_uploads 2000 → Permite até 2000 arquivos em um upload múltiplo.
• php_flag display_errors on e php_value error_reporting -1 → Ativa a exibição de erros e define a exibição para todos os tipos de erro.
• Bloco de RewriteEngine → Redireciona todas as requisições para o index.php, permitindo URLs amigáveis (roteamento do framework).

📌 Observações

• O .htaccess funciona apenas em servidores Apache com o módulo mod_rewrite habilitado.
• As configurações de PHP via php_value só funcionam se o PHP estiver rodando como módulo do Apache (mod_php).
• É possível descomentar e ajustar valores como post_max_size e upload_max_filesize conforme necessidade do projeto.

Arquivo /.env

O arquivo .env contém todas as variáveis de ambiente necessárias para configurar o SysFramework em seu servidor ou ambiente local. Ele não deve ser versionado em repositórios públicos quando contiver dados sensíveis.

🧩 Conteúdo Atual (Exemplo Seguro)

# ========================================
# Configurações do aplicativo
# ========================================
APP_NAME=SysFramework
APP_ENV=local
APP_KEY=base64:YOUR_APP_KEY_HERE
APP_DEBUG=false
APP_TIMEZONE=America/Sao_Paulo
APP_URL=http://localhost:8000
APP_LOCALE=utf-8

BCRYPT_ROUNDS=12

# ========================================
# Configurações do banco de dados
# ========================================
DB_CONNECTION=mysql
DB_CHARSET=utf8mb4
DB_COLLATION=utf8mb4_general_ci
DB_PREFIX=
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=sysframework
DB_USERNAME=root
DB_PASSWORD=secret

# ========================================
# Configurações de e-mail
# ========================================
MAIL_TRANSPORT=smtp
MAIL_HOST=smtp.example.com
MAIL_PORT=587
MAIL_USERNAME=your_username
MAIL_PASSWORD=your_password
MAIL_ENCRYPTION=tls
MAIL_FROM_ADDRESS=no-reply@example.com
MAIL_FROM_NAME=SysFramework
MAILER_DSN=smtp://your_username:your_password@smtp.example.com:587
MAIL_URL=http://example.com

# ========================================
# Configuração de teste
# ========================================
APP_TEST=teste

💡 Explicação das Configurações

• APP_NAME → Nome do aplicativo.
• APP_ENV → Ambiente da aplicação (local, production, staging, etc.).
• APP_KEY → Chave secreta da aplicação, usada para criptografia e tokens.
• APP_DEBUG → Habilita ou desabilita o modo debug.
• APP_TIMEZONE → Define o fuso horário padrão da aplicação.
• APP_URL → URL base do aplicativo.
• APP_LOCALE → Define a codificação padrão e idioma da aplicação.
• BCRYPT_ROUNDS → Número de rounds para gerar hashes bcrypt.
• Bloco DB_* → Configurações do banco de dados (host, porta, nome do DB, usuário e senha).
• Bloco MAIL_* → Configurações do serviço de envio de e-mail (SMTP ou outro transport).
• APP_TEST → Variável de teste ou ambiente temporário.

📌 Observações

• Substitua todos os valores sensíveis (senhas, APP_KEY, tokens) antes de usar em produção.
• O arquivo .env é lido pelo framework via SysEnv::load() e define constantes e variáveis importantes.
• É recomendável manter o arquivo .env fora de repositórios públicos e backups compartilhados.

Arquivo composer.json

O composer.json é o arquivo de configuração do Composer, usado para gerenciar dependências do SysFramework e configurar autoload, scripts e requisitos do projeto.

🧩 Conteúdo Atual

{
    "name": "syspanel/sysframework",
    "description": "PHP Framework - Version 2.0",
    "type": "project",
    "license": "MIT",
    "authors": [
        {
            "name": "Marco Costa",
            "email": "sysframework@syspanel.com.br"
        }
    ],
    "config": {
        "optimize-autoloader": true,
        "prepend-autoloader": false,
        "platform": {
            "php": "8.3.0"
        }
    },
    "require": {
        "php-di/php-di": "^7.0",
        "intervention/image": "^3.8",
        "gilbitron/easycsrf": "^1.5",
        "twbs/bootstrap": "5.3.3",
        "twitter/bootstrap": "*",
        "sceditor/sceditor": "^2.1",
        "symfony/mailer": "^7.1",
        "guzzlehttp/psr7": "^2.7",
        "middlewares/utils": "^4.0"
    },
    "autoload": {
        "psr-4": {
            "App\\": "app/",
            "App\\Controllers\\": "app/Controllers/",
            "App\\Models\\": "app/Models/",
            "App\\Services\\": "app/Services/",
            "App\\Middlewares\\": "app/Middlewares/",
            "App\\Handlers\\": "app/Handlers/",
            "Core\\": "core/",
            "Core\\Library": "core/library",
            "Database\\Migrations\\": "database/migrations",
            "Database\\Seeders\\": "database/seeders"
        }
    },
    "autoload-dev": {
        "psr-4": {
            "App\\Console\\Commands\\": "app/Console/Commands/"
        }
    },
    "scripts": {
        "post-install-cmd": [
            "Composer\\ScriptHandler::clearCache"
        ],
        "post-update-cmd": [
            "Composer\\ScriptHandler::clearCache"
        ]
    }
}

💡 Explicação das Configurações

• name → Nome do pacote ou projeto.
• description → Descrição do projeto.
• type → Tipo de pacote (aqui, project).
• license → Licença do projeto (MIT).
• authors → Informações do(s) autor(es).
• config → Configurações do Composer, como otimização do autoloader e plataforma PHP.
• require → Dependências obrigatórias do projeto.
• autoload → Mapeamento de namespaces para autoload (PSR-4) para produção.
• autoload-dev → Mapeamento de namespaces para autoload de desenvolvimento.
• scripts → Comandos executados automaticamente após instalar ou atualizar dependências.

📌 Observações

• As dependências podem ser atualizadas conforme necessidade do framework ou do projeto.
• O autoload PSR-4 permite que o Composer carregue automaticamente classes de acordo com namespaces e caminhos definidos.
• Os scripts post-install-cmd e post-update-cmd ajudam a limpar caches ou executar tarefas pós-instalação.

Arquivo LICENSE

O arquivo LICENSE define os termos da licença do SysFramework, garantindo direitos e responsabilidades aos usuários do software.

🧩 Conteúdo Atual

MIT License

Copyright (c) 2025 SysFramework (sysframework@syspanel.com.br)

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is provided to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM, OUT OF, OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

💡 Explicação da Licença MIT

• Permite usar, copiar, modificar, mesclar, publicar, distribuir, sublicenciar e/ou vender cópias do software.
• É necessário manter o aviso de copyright e a licença em todas as cópias ou partes substanciais do software.
• O software é fornecido "no estado em que se encontra", sem garantias de qualquer tipo.
• Os autores não são responsáveis por quaisquer danos ou responsabilidades decorrentes do uso do software.

📌 Observações

• A Licença MIT é altamente permissiva, permitindo uso comercial e privado sem restrições significativas.
• É recomendada para projetos de código aberto que desejam máxima liberdade de uso e distribuição.
• Inclua sempre o arquivo LICENSE ao distribuir o software.

Arquivo README.md

O arquivo README.md fornece uma visão geral do SysFramework, incluindo informações de instalação, requisitos, recursos, componentes externos e suporte.

🧩 Conteúdo Atual

SysFramework

sysframework.syspanel.com.br

MVC PHP Framework desenvolvido com uma estrutura robusta e modular para fornecer uma base sólida para a criação de aplicações web escaláveis e produtivas.

Versão 2.0

28/10/2025

Marco Costa (sysframework@syspanel.com.br)

## Requirements

* PHP 8.3

## Ferramentas

1 - SysCli
2 - SysORM
3 - SysTE
4 - SysRouter e Injeção de Dependências
5 - Bloqueio de IP por excesso de requisições
6 - Disponível uso de Request e Response
7 - SysTables

## Installation

1 - Extract SysFramework.zip no diretório html
2 - Ative permissão 0755 em todas as pastas e arquivos
3 - Ative permissão 0775 nos diretórios: cache, logs, storage, vendor
4 - Ative permissão 0644 nos arquivos .htaccess e public/.htaccess
5 - Configuração no Virtual Host Apache2:
    <Directory "/var/www/html/sysframework.syspanel.com.br/public">
        Options Indexes FollowSymLinks
        AllowOverride All
        Require all granted
    </Directory>
6 - Criar DB
7 - Configure .ENV

## Features

Core:

* Class SysLogger
* Class SysORM
* Class SysTE
* Class SysCli
* Class SysEnv
* Class SysImages
* Class SysSanitize
* Class Translator
* Class Validations
* Class SysMail
* Class Security
* Class SysRouter
* Class SysTables

Helpers:

* assets
* dd()
* sanitizeMiddleware()
* sanitize()
* generateCsrfToken()
* checkCsrfToken()
* old()
* bcrypt()
* back()
* e()
* blank()
* filled()

## Componentes externos

* twbs/bootstrap https://github.com/twbs/bootstrap MIT license
* php-di/php-di https://github.com/PHP-DI/PHP-DI MIT License
* sceditor/sceditor https://github.com/samclarke/SCEditor MIT License
* gilbitron/easycsrf https://github.com/gilbitron/EasyCSRF MIT License
* Symfony's Mailer https://symfony.com/doc/current/mailer.html MIT License
* guzzle/psr7 https://github.com/guzzle/psr7 MIT License

## PSR-7

https://www.php-fig.org/psr/psr-7/

## SysCli

php syscli Help 

## Suporte

Email: sysframework@syspanel.com.br

📜 Terms of Use

This project is licensed under the MIT License.

You can use, copy, modify, merge, publish, distribute, sublicense, or sell copies of the Software, as long as the license and copyright notice are included in all copies or substantial portions of the Software.

The Software is provided "as is", without warranties of any kind. For more details, see the MIT License.

For more information, contact: sysframework@syspanel.com.br

### Support the Project
If you find this project useful, consider supporting its development with a donation via PayPal:

[![Donate via PayPal](https://www.paypalobjects.com/en_US/i/btn/btn_donate_LG.gif)](https://www.paypal.com/donate/?business=marcocosta@gmx.com¤cy_code=USD)

© 2025 SysFramework - Under the MIT License.

💡 Explicação do README

• Fornece informações gerais do projeto, incluindo versão, autor e contato.
• Lista os requisitos mínimos de PHP.
• Descreve ferramentas e componentes principais do framework.
• Fornece instruções de instalação e configuração do ambiente.
• Documenta classes Core e helpers disponíveis.
• Lista os componentes externos utilizados com links e licenças.
• Indica suporte a PSR-7 e uso do SysCli.
• Inclui informações de suporte, termos de uso e forma de contribuir via doação.

📌 Observações

• Manter o README atualizado ajuda novos usuários e contribuintes a entenderem rapidamente o projeto.
• Incluir instruções claras de instalação e configuração evita problemas comuns.
• Fornecer links para documentação de componentes externos facilita o aprendizado e integração.

Arquivo syscli

O arquivo syscli é o ponto de entrada para a interface de linha de comando (CLI) do SysFramework. Ele permite executar comandos administrativos e utilitários diretamente pelo terminal.

🧩 Conteúdo Atual

<?php  

/************************************************************************/
/* SysFramework - PHP Framework                                         */
/* ============================                                         */
/*                                                                      */
/* PHP Framework                                                        */
/* (c) 2025 by Marco Costa sysframework@syspanel.com.br                 */
/*                                                                      */
/* https://sysframework.syspanel.com.br                                 */
/*                                                                      */
/* This project is licensed under the MIT License.                      */
/*                                                                      */
/* For more informations: sysframework@syspanel.com.br                  */
/************************************************************************/

require_once __DIR__ . '/vendor/autoload.php';

use Core\SysCli;

$cli = new SysCli();
$cli->handle($argv);

?>

💡 Explicação do Arquivo

• require_once __DIR__ . '/vendor/autoload.php'; → Carrega o autoloader do Composer, garantindo que todas as classes e dependências sejam carregadas automaticamente.
• use Core\SysCli; → Importa a classe responsável pela execução dos comandos CLI do framework.
• $cli = new SysCli(); → Cria uma instância da classe SysCli.
• $cli->handle($argv); → Passa os argumentos da linha de comando ($argv) para o manipulador de comandos do SysCli.
• Este arquivo permite executar comandos como php syscli Help para ver a lista de comandos disponíveis.

📌 Observações

• O arquivo syscli deve ser executado pelo terminal, dentro do diretório raiz do projeto.
• Todos os comandos do framework estão centralizados na classe SysCli, facilitando a manutenção e expansão.
• Os argumentos passados via CLI são capturados automaticamente em $argv e processados pela classe.

Classe Alert em /app/Components/Alert/Alert.php

A classe Alert é responsável por renderizar componentes de alerta reutilizáveis na interface do SysFramework. Ela utiliza o template Blade localizado em resources/views/components/Alert.blade.php.

🧩 Propriedades

• protected $attributes → Armazena os atributos passados para o componente, como tipo do alerta, mensagem, classes CSS, etc.

🛠️ Métodos

• __construct(array $attributes = []) → Inicializa a instância do alerta com os atributos fornecidos.
• render() → Renderiza o componente incluindo o template Blade correspondente e retorna o HTML gerado.

💡 Exemplo de Uso

use App\Components\Alert;

// Criar um alerta de sucesso
$alert = new Alert(['type' => 'success', 'message' => 'Operação realizada com sucesso!']);
echo $alert->render();

// Criar um alerta de erro
$alert = new Alert(['type' => 'error', 'message' => 'Ocorreu um erro!']);
echo $alert->render();

📌 Observações

• O componente utiliza templates Blade para separar a lógica da apresentação.
• Os atributos fornecidos no construtor podem ser customizados de acordo com o template.
• Pode ser integrado diretamente em views ou usado dentro de outras classes do SysFramework.

Classe MakeClientTableCommand em /app/Console/Commands/MakeClientTableCommand.php

Esta classe é responsável por criar a tabela clients no banco de dados e inserir clientes aleatórios para testes. É uma implementação de comando que pode ser executada pelo SysCli.

🧩 Propriedades

• private $pdo → Instância de PDO utilizada para executar comandos SQL no banco de dados.

🛠️ Métodos

• __construct(PDO $pdo) → Inicializa a classe recebendo a conexão PDO do banco de dados.
• execute() → Executa o comando, criando a tabela e inserindo clientes aleatórios.
• private createTable() → Cria a tabela clients se não existir.
• private insertRandomClients(int $count) → Insere $count clientes aleatórios na tabela clients.

💡 Exemplo de Uso

use App\Console\MakeClientTableCommand;

// Supondo que $pdo seja uma instância válida de PDO
$command = new MakeClientTableCommand($pdo);
$command->execute();

📌 Observações

• Os clientes inseridos são gerados aleatoriamente para testes e podem ser ajustados conforme necessário.
• O campo password é armazenado utilizando hash BCRYPT.
• O comando pode ser integrado ao SysCli para execução via terminal.

Classe MakeUserTableCommand em /app/Console/Commands/MakeUserTableCommand.php

Esta classe é responsável por criar a tabela users no banco de dados e inserir usuários aleatórios para testes. É uma implementação de comando que pode ser executada via SysCli.

🧩 Propriedades

• private $pdo → Instância de PDO utilizada para executar comandos SQL no banco de dados.

🛠️ Métodos

• __construct(PDO $pdo) → Inicializa a classe recebendo a conexão PDO do banco de dados.
• execute() → Executa o comando, criando a tabela e inserindo usuários aleatórios. Trata exceções para evitar falhas na execução.
• private createTable() → Cria a tabela users se não existir, incluindo colunas como firstname, lastname, password, email, date_of_birth, notes, is_active, role, verification_token, reset_token, reset_expires, confirmed_at, created_at e updated_at.
• private insertRandomUsers(int $count) → Insere $count usuários aleatórios na tabela users. Gera tokens de verificação aleatórios e define confirmed_at como null inicialmente.

💡 Exemplo de Uso

use App\Console\MakeUserTableCommand;

// Supondo que $pdo seja uma instância válida de PDO
$command = new MakeUserTableCommand($pdo);
$command->execute();

📌 Observações

• Os usuários inseridos são gerados aleatoriamente para testes e podem ser ajustados conforme necessário.
• O campo password é armazenado utilizando hash BCRYPT.
• O comando trata exceções para evitar falhas na inserção de registros duplicados ou inválidos.
• O comando pode ser integrado ao SysCli para execução via terminal.

Controller ApiUserController em /app/Controllers/Api/ApiUserController.php

Este controller fornece endpoints API RESTful para manipulação de usuários. Ele herda de SysController e utiliza o model User.

🛠️ Métodos

• index() → Retorna todos os usuários cadastrados em formato JSON.
• show($id) → Retorna os dados do usuário identificado por $id. Retorna erro 404 caso o usuário não exista.
• store() → Cria um novo usuário com os dados recebidos via $_POST e retorna o usuário criado em JSON com status 201.
• update($id) → Atualiza o usuário identificado por $id com os dados recebidos via $_POST. Retorna erro 404 caso o usuário não exista.
• delete($id) → Remove o usuário identificado por $id e retorna uma mensagem de confirmação. Retorna erro 404 caso o usuário não exista.

💡 Exemplo de Uso via API

// Listar todos os usuários
GET /api/users

// Visualizar um usuário específico
GET /api/users/{id}

// Criar um novo usuário
POST /api/users
Body: { "firstname": "John", "lastname": "Doe", "email": "john@example.com", ... }

// Atualizar usuário existente
PUT /api/users/{id}
Body: { "firstname": "Jane" }

// Deletar usuário
DELETE /api/users/{id}

📌 Observações

• As respostas são sempre em JSON, seguindo boas práticas de APIs REST.
• O controller utiliza o model User para todas as operações de banco de dados.
• Os métodos store e update usam fill() do model para popular os atributos de forma segura.
• É necessário tratar autenticação/autorização separadamente se a API for exposta externamente.

Controller AuthController em /app/Controllers/AuthController.php

Este controller gerencia todo o fluxo de autenticação do sistema, incluindo registro, login, logout, redefinição de senha e confirmação de email. Ele herda de BaseController e utiliza diversos serviços, logger e templates do SysTE.

🛠️ Métodos

• register() → Exibe o formulário de registro.
• newregister() → Processa o registro de um novo usuário, valida dados, cria registro no banco e envia email de confirmação.
• sendConfirmationEmail($email, $userId) → Envia email de confirmação para um usuário com token único.
• confirm_email() → Confirma o email de um usuário usando token e ID enviados via URL.
• registred() → Exibe a página de confirmação de registro, usando dados armazenados na sessão.
• login() → Exibe o formulário de login.
• gologin() → Processa o login, verifica email, senha e confirmação, e inicia a sessão.
• logout() → Encerra a sessão do usuário e redireciona para a página inicial.
• forgotPassword() → Exibe o formulário de solicitação de redefinição de senha.
• sendResetLink() → Gera token de redefinição e envia link por email.
• resetPassword() → Exibe formulário para redefinir senha.
• goresetPassword() → Valida token e atualiza a senha do usuário.
• resendConfirmation() → Exibe formulário para reenviar email de confirmação.
• goresendConfirmation() → Valida email e reenvia email de confirmação.
• goforgotPassword() → Processa envio de email de redefinição, com validação de email.
• resendConfirmationEmail() → Processa reenvio de email de confirmação para usuários não confirmados.

💡 Fluxo de Trabalho

1. Usuário acessa /register → formulário de registro.
2. Submete dados → newregister() valida, cria registro e envia email de confirmação.
3. Email contém token → usuário acessa link → confirm_email() confirma registro.
4. Login → gologin() valida email e senha, inicia sessão.
5. Redefinição de senha → forgotPassword() + sendResetLink() + goresetPassword().
6. Reenvio de confirmação → resendConfirmation() + goresendConfirmation() + resendConfirmationEmail().

📌 Observações

• O controller utiliza SysTE para renderizar views.
• O Mailer é configurado via MAILER_DSN e usado para envio de emails de confirmação e redefinição de senha.
• Todos os métodos de formulário possuem validação usando \Core\Validations.
• Logs são gravados usando SysLogger para auditoria de registros, logins, erros de validação e ações de email.
• É importante que as rotas estejam corretamente configuradas no SysRouter para apontar para cada método do controller.

Controller ClientController em /app/Controllers/ClientController.php

Este controller gerencia todas as operações relacionadas aos clientes do sistema, incluindo CRUD (Create, Read, Update, Delete). Ele herda de BaseController e utiliza SysTE para renderizar templates, SysLogger para registro de logs, e os objetos Request e Response para manipulação de requisições e respostas.

🛠️ Métodos

🔹 index()

Lista todos os clientes e renderiza a view clients.index.

public function index() {
    $this->logger->info('(clients.index) - Carregando lista de clientes.');
    $clients = Client::all();
    return $this->response->send($this->sysTE->render('clients.index', ['clients' => $clients]));
}

• $this->logger->info(...) → grava log da ação.
• Client::all() → retorna todos os clientes do banco.
• $this->sysTE->render(...) → renderiza template HTML.
• $this->response->send(...) → envia o HTML para o navegador.

🔹 create()

Exibe o formulário para criação de um novo cliente (clients.create).

public function create() {
    return $this->response->send($this->sysTE->render('clients.create'));
}

🔹 store()

Recebe dados do formulário via POST, cria um cliente no banco e redireciona para a lista.

public function store() {
    $data = $this->request->post();
    $data['password'] = password_hash($data['password'], PASSWORD_BCRYPT);
    Client::create($data);
    return $this->response->redirect('/clients');
}

• $this->request->post() → obtém dados enviados via POST.
• password_hash(...) → criptografa senha do cliente.
• Client::create($data) → insere cliente no banco.
• $this->response->redirect(...) → redireciona para lista de clientes.

🔹 edit($id)

Exibe formulário de edição do cliente identificado pelo $id (clients.edit).

public function edit($id) {
    $client = Client::find($id);
    return $this->response->send($this->sysTE->render('clients.edit', ['client' => $client]));
}

🔹 update($id)

Atualiza os dados do cliente identificado pelo $id com os dados do POST e redireciona para a lista.

public function update($id) {
    $data = $this->request->post();
    $data['password'] = password_hash($data['password'], PASSWORD_BCRYPT);
    $client = Client::find($id);
    if ($client) {
        $client->update($data);
    }
    return $this->response->redirect('/clients');
}

🔹 show($id)

Exibe detalhes de um cliente específico (clients.show).

public function show($id) {
    $client = Client::find($id);
    return $this->response->send($this->sysTE->render('clients.show', ['client' => $client]));
}

🔹 delete($id)

Remove o cliente do banco de dados e redireciona para a lista de clientes.

public function delete($id) {
    Client::destroy($id);
    return $this->response->redirect('/clients');
}

💡 Fluxo de Trabalho

1. Acessar /clients → lista de clientes.
2. Criar novo cliente → /clients/create → enviar formulário → store().
3. Editar cliente → /clients/edit/{id} → atualizar dados → update().
4. Visualizar cliente → /clients/show/{id} → detalhes do cliente.
5. Deletar cliente → /clients/delete/{id} → remove do banco.

📌 Observações

• Senhas criptografadas com password_hash + BCRYPT.
• Logs das ações gravados com SysLogger.
• Rotas devem estar configuradas corretamente no SysRouter.
• O controller usa métodos estáticos do modelo Client para operações no banco.
• O controller segue o padrão MVC, separando claramente responsabilidades de Model, View e Controller.

Controller HomeController em /app/Controllers/HomeController.php

O HomeController gerencia a página inicial e exemplos do sistema. Ele herda de BaseController e utiliza SysTE para renderizar templates, além de SysLogger para registro de logs.

🛠️ Propriedades

• $sysTE → instância da template engine para renderização de views.
• $logger → instância de SysLogger para gravar logs de informações, avisos e erros.

🔹 __construct()

Construtor do controller, responsável por inicializar o SysTE e o SysLogger.

public function __construct() {
    $this->sysTE = new SysTE(VIEWS_PATH, VIEWSCACHE_PATH);
    $this->logger = new SysLogger();
}

🔹 index()

Método principal que exibe a página inicial do sistema.

public function index() {
    $logger = new SysLogger();
    $logger->info('(home.index) - Esta é uma mensagem de informação.');
    echo $this->sysTE->render('home.index');
}

• Cria uma instância de SysLogger e registra mensagens de log.
• Renderiza a view home.index usando SysTE.

🔹 example()

Método de exemplo para demonstração de envio de dados para a view.

public function example() {
    $logger = new SysLogger();
    $logger->info('(home.example) - Esta é uma mensagem de informação.');

    $data = [
        'user' => ['name' => 'João', 'is_admin' => true],
        'items' => ['Item 1', 'Item 2', 'Item 3']
    ];

    echo $this->sysTE->render('home.example', $data);
}

• Exemplo de passagem de dados para o template ($data).
• Mostra como renderizar listas e informações do usuário na view.

🔹 syste()

Método de exemplo mostrando envio de dados simples para a view home.syste.

public function syste() {
    $logger = new SysLogger();
    $logger->info('(home.syste) - Esta é uma mensagem de informação.');

    $data = ['name' => 'Marco Costa'];

    echo $this->sysTE->render('home.syste', $data);
}

• Registra informações no log.
• Renderiza a view home.syste com dados simples.

🔹 systables()

Método que renderiza a view syscss.systables, utilizada para demonstração de tabelas ou componentes CSS do sistema.

public function systables() {
    $logger = new SysLogger();
    $logger->info('(home.systables) - Esta é uma mensagem de informação.');

    echo $this->sysTE->render('syscss.systables');
}

💡 Observações

• Todos os métodos criam uma instância de SysLogger para registrar logs de informações.
• As views são renderizadas com SysTE, usando dados passados através de arrays associativos.
• O controller segue o padrão MVC, mantendo a lógica separada da apresentação.
• Exemplos como example() e syste() servem para testes ou demonstrações de templates.

💡 Fluxo de Trabalho

1. Acessar /home/index → página inicial.
2. Acessar /home/example → demonstra dados de usuário e lista de itens.
3. Acessar /home/syste → demonstra envio de dados simples para template.
4. Acessar /home/systables → exibe tabela ou componentes CSS do sistema.

Middleware ApiAuthMiddleware em /app/Middlewares/ApiAuthMiddleware.php

O ApiAuthMiddleware é responsável por interceptar requisições para rotas de API e verificar se o usuário está autorizado a acessar os recursos, utilizando tokens de autenticação (JWT, OAuth ou outro método). Ele atua como um filtro antes que a requisição chegue ao controller.

🛠️ Métodos

• handle($request, $next) → Intercepta a requisição, verifica o token de autorização e permite ou bloqueia o acesso.
• validateToken($token) → Valida o token enviado pelo cliente. Retorna true se o token for válido, false caso contrário.

🔹 handle($request, $next)

public function handle($request, $next) {
    $token = $request->getHeader('Authorization');

    if ($this->validateToken($token)) {
        return $next($request); // Passa a requisição adiante para o próximo middleware ou controller
    }

    return json_encode(['error' => 'Unauthorized'], 401); // Retorna erro 401 se não autorizado
}

• Recupera o token de autorização do cabeçalho HTTP (Authorization).
• Chama validateToken() para verificar se o token é válido.
• Se válido, a requisição continua com $next($request).
• Se inválido, retorna uma resposta JSON com erro 401 (Unauthorized).

🔹 validateToken($token)

private function validateToken($token) {
    // Exemplo simples de validação
    return $token === 'valid_token';
}

• Este método é privado, usado internamente pelo middleware.
• No exemplo atual, compara o token com uma string fixa 'valid_token'.
• Em sistemas reais, aqui você implementaria validação JWT, OAuth ou consulta a banco de dados.

💡 Observações

• Middlewares atuam como filtros antes do controller, permitindo implementar autenticação, autorização, logging, caching, etc.
• O ApiAuthMiddleware deve ser registrado na rota ou grupo de rotas que precisam de autenticação.
• O retorno JSON com status 401 garante que APIs respondam corretamente quando o acesso não é autorizado.

💡 Fluxo de Trabalho

1. Requisição chega a uma rota protegida.
2. Middleware ApiAuthMiddleware executa handle().
3. Recupera o token do cabeçalho Authorization.
4. Chama validateToken() para validar o token.
5. Se válido → requisição continua para o próximo middleware ou controller.
6. Se inválido → retorna JSON com erro 401.

Middleware AuthMiddleware em /app/Middlewares/AuthMiddleware.php

O AuthMiddleware protege rotas que requerem autenticação de usuário. Ele verifica se há um usuário logado na sessão antes de permitir o acesso ao controller. Atua como um filtro de autenticação antes que a requisição chegue ao controller.

🛠️ Método

• handle($request, $next) → Intercepta a requisição, verifica se o usuário está autenticado e permite ou bloqueia o acesso.

🔹 handle($request, $next)

public function handle($request, $next) {
    if (!isset($_SESSION['user_id'])) {
        // Redirecionar ou retornar erro se não autenticado
        return ['error' => 'Você não está autenticado.'];
    }
    return $next($request); // Permite continuar para o próximo middleware ou controller
}

• Verifica se existe a variável $_SESSION['user_id'], indicando que o usuário está logado.
• Se não estiver logado, retorna um array com mensagem de erro.
• Se estiver logado, chama $next($request) para continuar o fluxo.

💡 Observações

• Este middleware é útil para proteger páginas internas do sistema que requerem login.
• O retorno de erro pode ser substituído por um redirecionamento para a página de login, se desejado.
• Middlewares de autenticação devem ser registrados nas rotas que exigem login.
• Este exemplo usa sessão PHP, mas poderia ser adaptado para tokens de API ou outras formas de autenticação.

💡 Fluxo de Trabalho

1. Requisição chega a uma rota protegida.
2. Middleware AuthMiddleware executa handle().
3. Verifica se $_SESSION['user_id'] está definido.
4. Se definido → requisição continua para o próximo middleware ou controller.
5. Se não definido → retorna erro ou redireciona para login.

Model Auth em /app/Models/Auth.php

O Auth é o modelo responsável por gerenciar usuários no sistema. Ele estende SysORM, que oferece métodos básicos de acesso ao banco de dados. Este modelo lida com criação, atualização, confirmação de usuários, tokens de verificação e redefinição de senha.

🛠️ Propriedades

• $table → define a tabela no banco de dados (users).
• $fillable → campos que podem ser preenchidos via mass assignment.
• $hidden → campos que não devem ser expostos (como senha e tokens).

🔹 Métodos Principais

create($data)

Cria um novo usuário no banco de dados.

public static function create($data) {
    // Insere dados do usuário na tabela
    // Retorna o ID do registro criado
}

saveConfirmationToken($userId, $token)

Salva o token de verificação para confirmação de email do usuário.

public function saveConfirmationToken($userId, $token) {
    // Atualiza o campo verification_token do usuário
    // Retorna verdadeiro se atualização foi bem-sucedida
}

verifyToken($userId, $token)

Verifica se o token de confirmação é válido para o usuário informado.

public static function verifyToken($userId, $token) {
    // Retorna verdadeiro se o token corresponder ao registro no banco
}

confirmUser($userId)

Confirma o usuário, marcando confirmed_at e removendo o token.

public static function confirmUser($userId) {
    // Atualiza o usuário como confirmado
    // Retorna verdadeiro se a confirmação for bem-sucedida
}

where($column, $value)

Busca todos os usuários que correspondem a um determinado valor em uma coluna.

public static function where($column, $value) {
    // Retorna array com todos os registros encontrados
}

saveResetToken($userId, $token)

Salva um token de redefinição de senha e define validade de 1 hora.

public static function saveResetToken($userId, $token) {
    // Atualiza reset_token e reset_expires
    // Retorna verdadeiro se a atualização for bem-sucedida
}

verifyResetToken($userId, $token)

Verifica se o token de redefinição de senha ainda é válido.

public static function verifyResetToken($userId, $token) {
    // Retorna verdadeiro se o token existir e não estiver expirado
}

updatePassword($userId, $newPassword)

Atualiza a senha do usuário e remove o token de redefinição.

public static function updatePassword($userId, $newPassword) {
    // Atualiza o campo password e limpa reset_token e reset_expires
}

💡 Observações

• Campos sensíveis como password, verification_token e reset_token são protegidos via $hidden.
• O modelo usa métodos estáticos e instâncias internas para manipulação de dados.
• O sistema suporta confirmação de usuário via token e recuperação de senha com token temporário.
• Todos os métodos que alteram o banco retornam verdadeiro ou falso para indicar sucesso da operação.

Model Auth em /app/Models/Auth.php

O Auth é o modelo responsável por gerenciar usuários no sistema. Ele estende SysORM, que oferece métodos básicos de acesso ao banco de dados. Este modelo lida com criação, atualização, confirmação de usuários, tokens de verificação e redefinição de senha.

🛠️ Propriedades

• $table → define a tabela no banco de dados (users).
• $fillable → campos que podem ser preenchidos via mass assignment.
• $hidden → campos que não devem ser expostos (como senha e tokens).

🔹 Métodos Principais

create($data)

Cria um novo usuário no banco de dados.

public static function create($data) {
    // Insere dados do usuário na tabela
    // Retorna o ID do registro criado
}

saveConfirmationToken($userId, $token)

Salva o token de verificação para confirmação de email do usuário.

public function saveConfirmationToken($userId, $token) {
    // Atualiza o campo verification_token do usuário
    // Retorna verdadeiro se atualização foi bem-sucedida
}

verifyToken($userId, $token)

Verifica se o token de confirmação é válido para o usuário informado.

public static function verifyToken($userId, $token) {
    // Retorna verdadeiro se o token corresponder ao registro no banco
}

confirmUser($userId)

Confirma o usuário, marcando confirmed_at e removendo o token.

public static function confirmUser($userId) {
    // Atualiza o usuário como confirmado
    // Retorna verdadeiro se a confirmação for bem-sucedida
}

where($column, $value)

Busca todos os usuários que correspondem a um determinado valor em uma coluna.

public static function where($column, $value) {
    // Retorna array com todos os registros encontrados
}

saveResetToken($userId, $token)

Salva um token de redefinição de senha e define validade de 1 hora.

public static function saveResetToken($userId, $token) {
    // Atualiza reset_token e reset_expires
    // Retorna verdadeiro se a atualização for bem-sucedida
}

verifyResetToken($userId, $token)

Verifica se o token de redefinição de senha ainda é válido.

public static function verifyResetToken($userId, $token) {
    // Retorna verdadeiro se o token existir e não estiver expirado
}

updatePassword($userId, $newPassword)

Atualiza a senha do usuário e remove o token de redefinição.

public static function updatePassword($userId, $newPassword) {
    // Atualiza o campo password e limpa reset_token e reset_expires
}

💡 Observações

• Campos sensíveis como password, verification_token e reset_token são protegidos via $hidden.
• O modelo usa métodos estáticos e instâncias internas para manipulação de dados.
• O sistema suporta confirmação de usuário via token e recuperação de senha com token temporário.
• Todos os métodos que alteram o banco retornam verdadeiro ou falso para indicar sucesso da operação.

Service AuthService em /app/Services/AuthService.php

O AuthService é responsável por gerenciar toda a lógica de autenticação e registro de usuários. Ele atua como intermediário entre os models (User, Auth) e os controladores, abstraindo funcionalidades de login, logout, registro e recuperação de senha.

🛠️ Métodos Principais

attempt(array $credentials)

Tenta autenticar um usuário com as credenciais fornecidas.

public function attempt(array $credentials) {
    return Auth::attempt($credentials); // Retorna verdadeiro se autenticação for bem-sucedida
}

logout()

Encerra a sessão do usuário logado.

public function logout() {
    Auth::logout(); // Limpa a sessão e cookies relacionados
}

user()

Retorna os dados do usuário atualmente autenticado.

public function user() {
    return Auth::user(); // Retorna objeto do usuário logado ou null se não houver
}

register(array $data)

Cria um novo usuário, aplicando hash na senha antes de salvar.

public function register(array $data) {
    $data['password'] = Hash::make($data['password']); // Criptografa a senha
    return User::create($data); // Salva o usuário no banco
}

recoverPassword($email)

Inicia o processo de recuperação de senha para o usuário informado.

public function recoverPassword($email) {
    // Implementa lógica de envio de e-mail com token de redefinição
}

confirmRegistration($token)

Confirma o registro de um usuário usando o token de verificação enviado por e-mail.

public function confirmRegistration($token) {
    // Implementa lógica para validar token e confirmar usuário
}

💡 Observações

• Abstrai a complexidade de autenticação e registro para os controladores.
• Garante que senhas sejam sempre armazenadas de forma segura usando hash.
• Centraliza a lógica de recuperação de senha e confirmação de registro.
• Facilita testes e manutenção, pois o controlador não precisa lidar diretamente com o model User.

Service SysCacheService em /app/Services/SysCacheService.php

O SysCacheService é responsável por gerenciar cache de dados no sistema utilizando arquivos no servidor. Ele permite armazenar, recuperar e limpar dados temporários, melhorando a performance ao evitar consultas ou cálculos repetitivos.

🛠️ Propriedades

• private $cacheDir → Diretório onde os arquivos de cache são armazenados.

🛠️ Métodos Principais

__construct($cacheDir)

Construtor que define o diretório de cache e cria a pasta caso não exista.

public function __construct($cacheDir = __DIR__ . '/../cache') {
    $this->cacheDir = $cacheDir;
    if (!is_dir($this->cacheDir)) {
        mkdir($this->cacheDir, 0777, true); // Cria a pasta de cache
    }
}

set($key, $data, $ttl)

Armazena dados no cache com uma chave única e tempo de expiração (TTL).

public function set($key, $data, $ttl = 3600) {
    $file = $this->getCacheFile($key);
    $cacheData = [
        'expires' => time() + $ttl,
        'data' => $data
    ];
    file_put_contents($file, serialize($cacheData)); // Salva no arquivo
}

get($key)

Recupera dados do cache usando a chave. Retorna null se o cache expirou ou não existe.

public function get($key) {
    $file = $this->getCacheFile($key);
    if (!file_exists($file)) return null;

    $cacheData = unserialize(file_get_contents($file));
    if ($cacheData['expires'] < time()) {
        unlink($file); // Remove cache expirado
        return null;
    }

    return $cacheData['data'];
}

clear($key)

Remove o cache correspondente a uma chave específica.

public function clear($key) {
    $file = $this->getCacheFile($key);
    if (file_exists($file)) unlink($file);
}

clearAll()

Limpa todos os arquivos de cache no diretório.

public function clearAll() {
    foreach (glob($this->cacheDir . '/*') as $file) {
        unlink($file); // Remove todos os arquivos
    }
}

getCacheFile($key)

Gera o caminho do arquivo de cache baseado na chave, usando md5 para criar nomes únicos.

private function getCacheFile($key) {
    return $this->cacheDir . '/' . md5($key) . '.cache';
}

💡 Observações

• O cache é baseado em arquivos no servidor e cada chave gera um arquivo distinto.
• O TTL define por quanto tempo o cache é válido, evitando dados desatualizados.
• O serviço permite limpar cache individual (clear) ou total (clearAll).
• O uso do serialize e unserialize permite armazenar qualquer tipo de dado PHP (arrays, objetos, etc).
• Ideal para acelerar consultas pesadas ou armazenar resultados de cálculos frequentes.

Service SysQueueService em /app/Services/SysQueueService.php

O SysQueueService gerencia uma fila de tarefas simples utilizando um arquivo JSON no servidor. Ele permite adicionar tarefas à fila e processá-las posteriormente, garantindo que execuções longas ou assíncronas possam ser controladas.

🛠️ Propriedades

• private $queueFile → Caminho do arquivo JSON onde as tarefas da fila são armazenadas.

🛠️ Métodos Principais

__construct($queueFile)

Construtor que define o arquivo da fila e cria o arquivo caso não exista.

public function __construct($queueFile = __DIR__ . '/../cache/queue.json') {
    $this->queueFile = $queueFile;
    if (!file_exists($this->queueFile)) {
        file_put_contents($this->queueFile, json_encode([])); // Cria arquivo vazio
    }
}

push($task)

Adiciona uma nova tarefa à fila.

public function push($task) {
    $queue = json_decode(file_get_contents($this->queueFile), true);
    $queue[] = $task; // Adiciona a tarefa ao array
    file_put_contents($this->queueFile, json_encode($queue)); // Salva novamente no arquivo
}

process()

Processa todas as tarefas da fila. Após o processamento, a fila é esvaziada.

public function process() {
    $queue = json_decode(file_get_contents($this->queueFile), true);
    foreach ($queue as $task) {
        // Implementar processamento da tarefa aqui
        // Ex: chamar função, executar comando, enviar e-mail etc.
    }
    file_put_contents($this->queueFile, json_encode([])); // Limpa a fila
}

💡 Observações

• O serviço utiliza um arquivo JSON simples como armazenamento da fila.
• Cada chamada a push() adiciona uma tarefa ao final da fila.
• O método process() deve ser implementado conforme a lógica específica das tarefas do sistema.
• Após o processamento, a fila é esvaziada, garantindo que nenhuma tarefa seja executada duas vezes.
• Ideal para executar tarefas assíncronas simples sem depender de bancos de dados ou sistemas de fila externos.

Request UserRequest em /app/Requests/UserRequest.php

O UserRequest é responsável por centralizar a validação e autorização de dados enviados em formulários relacionados ao usuário. Ele herda da classe Request do SysORM, que fornece métodos para validação de dados e autorização.

🛠️ Métodos Principais

rules()

Define as regras de validação para os dados do usuário.

public function rules() {
    return [
        'name' => 'required|string|max:255',
        'email' => 'required|email|unique:users,email,' . ($this->user() ? $this->user()->id : ''),
        'password' => 'required|string|min:8|confirmed',
        // Adicione outras regras conforme necessário
    ];
}

Explicação:

• required → o campo é obrigatório.
• string → deve ser do tipo string.
• max:255 → tamanho máximo de 255 caracteres.
• email → deve ser um e-mail válido.
• unique:users,email,ID → garante que o e-mail seja único na tabela users, exceto para o ID do usuário atual.
• min:8 → senha mínima de 8 caracteres.
• confirmed → senha deve ter confirmação (campo password_confirmation).

authorize()

Define se o usuário tem permissão para realizar a requisição.

public function authorize() {
    return true; // Permite acesso para todos
}

validated()

Retorna os dados validados após a execução das regras.

public function validated() {
    return parent::validated();
}

💡 Observações

• O UserRequest centraliza a lógica de validação, evitando duplicação de regras nos controllers.
• Você pode estender as regras para campos adicionais conforme a necessidade do sistema.
• O método authorize() pode ser personalizado para verificar permissões específicas do usuário.
• O uso de validated() garante que apenas os dados que passaram nas regras de validação sejam utilizados no sistema.

Rotas do Sistema routes/web.php

Este arquivo define todas as rotas do SysFramework, incluindo rotas públicas, rotas protegidas por middleware, autenticação, CRUD de clientes e páginas administrativas. Ele utiliza a classe SysRouter para registrar rotas e grupos de rotas, permitindo prefixos e middlewares.

🛠️ Rotas Públicas

• / → HomeController@index → Página inicial.
• /example → HomeController@example → Exemplo de renderização com dados.
• /syste → HomeController@syste → Exemplo de renderização de dados customizados.
• /systables → HomeController@systables → Exibe tabelas do sistema.

📋 Rotas de Clientes

Grupo de rotas com prefixo /clients, correspondendo ao CRUD do ClientController.

• /clients → Lista todos os clientes (index()).
• /clients/create → Formulário de criação (create()).
• /clients [POST] → Armazena novo cliente (store()).
• /clients/edit/{id} → Formulário de edição (edit($id)).
• /clients/update/{id} [PUT] → Atualiza cliente (update($id)).
• /clients/show/{id} → Visualiza detalhes (show($id)).
• /clients/delete/{id} → Remove cliente (delete($id)).

🛡️ Rotas Administrativas

Grupo protegido pelo AuthMiddleware, prefixo /admin:

• /admin e /admin/dashboard → AdminController@dashboard.
• /admin/users → AdminController@users.
• /admin/settings → AdminController@settings.
• Outras rotas incluem: buttons, cards, utilities_color, utilities_border, utilities_animation, utilities_other, blank, charts, tables.

🔐 Autenticação

• /register → Formulário de registro (AuthController@register).
• /newregister [POST] → Cria novo usuário (newregister()).
• /registred → Confirmação de registro (registred()).
• /confirm_email e /confirmemail → Confirmação de e-mail.
• /login → Formulário de login (login()).
• /gologin [POST] → Autentica usuário (gologin()).
• /logout → Logout do usuário (logout()).

🔄 Recuperação de Senha

• /forgot_password → Formulário de recuperação (forgotPassword()).
• /send_resetlink [POST] → Envia link de recuperação (sendResetLink()).
• /reset_password → Formulário de redefinição (resetPassword()).
• /goreset_password [POST] → Atualiza a senha (goresetPassword()).

📦 Outras Funcionalidades

• Rota para arquivos estáticos: /assets/{path}.
• Rota de erro 404 personalizada, registrando a URL e exibindo uma página amigável.
• Suporte a cache de rotas (comentado: SysRouter::cacheRoutes()).

💡 Observações

• O arquivo inicia a sessão caso ainda não esteja iniciada (session_start()).
• Middlewares podem ser aplicados em grupos de rotas para proteção de acesso.
• O uso de SysRouter::group facilita a organização de prefixos e middlewares.
• O logger SysLogger é utilizado para registrar acessos e erros, como na página 404.