Classe Galastri

Classe Galastri

Localizado em galastri/core/Galastri.php.

• A classe Galastri é responsável por unir todas as demais classes, módulos, extensões, etc.

• Ele verifica o resultado retornado pela classe Router, aplica as configurações conforme o necessário, executa o método da classe controller quando necessário e repassa os dados para um dos formatos de saída.

---

Constantes

private const MODULE_CONTROLLER = 'galastri\modules\Controller';
private const OUTPUT_NAMESPACE = 'galastri\core\output';

Nome	Descrição
MODULE_CONTROLLER	Define o namespace da classe pai Controller que contém os métodos para processamento e retorno dos dados.
OUTPUT_NAMESPACE	O namespace padrão dos formatos de saída. É necessário pois o termo use não funciona para classes importadas dinamicamente, o que é o caso das classes de formato de saída.

---

Propriedades

private static string $controllerNamespace = '';
private static string $controllerMethodName = '';
private static string $controllerHttpMethodName = '';

private static bool $controllerExists = true;
private static bool $controllerMethodExists = true;

private static string $output;
private static ?object $controller = null;

Nome	Tipo	Descrição
$controllerNamespace	string	Armazena o namespace da controller, conforme definido pela rota.
$controllerMethodName	string	O método que será executado da controller, conforme definido pela rota.
$controllerHttpMethodName	string	O método de requisição HTTP que será executado da controller, caso definido na rota.
$controllerExists	bool	Armazena se a classe controller existe ou não.
$controllerMethodExists	bool	Armazena se o método existe na classe controller.
$output	string	Armazena o nome do formato de saída.
$controller	null object	Armazena um objeto da classe Controller.

---

Métodos

__construct()

private function __construct() {}

A classe Galastri é uma classe estática, portanto, seu método __construct() é vazio e possui a visibilidade private.

________________

run()

public static function run(): void
{
    Config::run();
    Router::run();

    self::setOutputClass();
    self::checkForceRedirectTo();
    self::checkOffline();
    self::isValidRoute();
    self::checkAuthentication();
    self::setControllerNamespace();
    self::setMethodName();
    self::setHttpMethodName();

    if (self::controllerExists()) {
        self::executeController();
    }

    self::executeOutput();
}

Método principal responsável por iniciar e coordenar a execução do framework. Ele reúne as classes e configurações necessárias, realizando validações e verificações para garantir que a execução ocorra corretamente.

Caso haja alguma inconsistência, o método pode redirecionar a execução ou exibir mensagens de erro apropriadas.

• PARÂMETROS:

  Este método não possui parâmetros.

• RETORNO:

  Este método não retorna dados.

• EXPLICAÇÃO:

  A execução segue uma sequência lógica:

  a.) Carregamento de configurações e rotas: As classes Config e Router são inicializadas.

  b.) Definição do fluxo de execução: São realizadas verificações como checkForceRedirectTo(), checkOffline() e isValidRoute(), garantindo que a requisição pode prosseguir.

  c.) Autenticação e controle de acesso: O método checkAuthentication() verifica se o usuário está autenticado para acessar a rota.

  d.) Determinação do controlador e do método: O namespace e os métodos do controller são definidos (setControllerNamespace(), setMethodName(), setHttpMethodName()).

  e.) Execução do controlador e da saída: Se um controller válido existir, ele será executado, e o framework finalizará com executeOutput().

________________

checkForceRedirectTo()

private static function checkForceRedirectTo(): void
{
    $forceRedirectTo = Config::get('forceRedirectTo');

    if ($forceRedirectTo !== '') {
        // Redirect::to($forceRedirectTo);
    }
}

Verifica se a configuração forceRedirectTo está vazia. Caso não, a execução deve ser interrompida e a requisição redirecionada para o endereço especificado.

• PARÂMETROS:

  Este método não possui parâmetros.

• RETORNO:

  Este método não retorna dados.

________________

checkOffline()

private static function checkOffline(): void
{
    $offline = Config::get('offline');
    $offlineRedirectTo = Config::get('offlineRedirectTo');
    $offlineMessage = Config::get('offlineMessage');

    if ($offline) {

        if ($offlineRedirectTo !== '') {
            // Redirect::to($offlineRedirectTo);
        }

        throw new Exception(
            $offlineMessage
        );
    }
}

Verifica se a aplicação está em modo offline. Caso a configuração offline esteja ativada (true), a execução é interrompida.

• PARÂMETROS:

  Este método não possui parâmetros.

• RETORNO:

  Este método não retorna dados.

• EXPLICAÇÃO:

  • Redirecionamento: Se offlineRedirectTo estiver definido, o usuário será redirecionado para o endereço configurado.
  • Exibição de mensagem: Caso contrário, uma exceção será lançada contendo a mensagem definida em offlineMessage.

________________

isValidRoute()

private static function isValidRoute(): void
{
    if (!Router::isValidRoute() and self::$output::requiresController()) {
        self::notFound();
    }
}

Verifica se a rota é válida conforme as definições da classe Router. Caso a rota não seja válida e o formato de saída exija um controller, a execução é interrompida e o usuário recebe ou é redirecionado para uma página de erro de rota não encontrada.

• PARÂMETROS:

  Este método não possui parâmetros.

• RETORNO:

  Este método não retorna dados.

________________

notFound()

public static function notFound(): void
{
    $output = Config::get('output');
    $notFoundRedirectTo = Config::get('notFoundRedirectTo');
    $notFoundMessage = Config::get('notFoundMessage');

    if ($notFoundRedirectTo !== '' and $output != 'json') {
        exit(header('Location: '.$notFoundRedirectTo));
        // Redirect::to($notFoundRedirectTo));
    }

    header("HTTP/1.0 404 Not Found");
    throw new Exception(
        $notFoundMessage
    );
}

Este método é chamado quando a execução precisa retornar um erro 404 - Not Found. O comportamento depende das configurações definidas em Config:

• PARÂMETROS:

  Este método não possui parâmetros.

• RETORNO:

  Este método não retorna dados.

• EXPLICAÇÃO:

  • Se notFoundRedirectTo estiver definido e o formato de saída não for json, o usuário será redirecionado para o endereço especificado.

  • Se não houver redirecionamento, o cabeçalho* HTTP 404 Not Found* será enviado, e uma exceção será lançada contendo a mensagem definida em notFoundMessage.

________________

checkAuthentication()

private static function checkAuthentication(): void
{
    $authTag = Config::get('authTag');
    $authFailRedirectTo = Config::get('authFailRedirectTo');
    $authFailMessage = Config::get('authFailMessage');
    $output = Config::get('output');

    if ($authTag !== '') {
        if (/*Authentication::validate($authTag) === */false) {


            if ($authFailRedirectTo !== '' and $output != 'json') {
                // Redirect::to($authFailRedirectTo);
            }

            throw new Exception(
                $authFailMessage
            );
        }
    }
}

Verifica se uma authTag foi definida. Caso sim, então é verificado se o usuário possui a autenticação necessária. Caso não, então há duas possibilidades:

- Se `authFailRedirectTo` estiver definido e o formato de saída não for `json`, o usuário será redirecionado para o endereço especificado.

- Se não houver redirecionamento, uma exceção será lançada contendo a mensagem definida em `authFailMessage`.

• PARÂMETROS:

  Este método não possui parâmetros.

• RETORNO:

  Este método não retorna dados.

• EXPLICAÇÃO:

  • Verifica se uma authTag foi definida. Caso positivo, ele valida se o usuário possui a autenticação necessária. Se a autenticação falhar, o comportamento segue uma das seguintes abordagens:

  • Se authFailRedirectTo estiver definido e o formato de saída não for json, o usuário será redirecionado para o endereço especificado.

  • Se não houver redirecionamento, uma exceção será lançada com a mensagem definida em authFailMessage.

________________

setOutputClass()

private static function setOutputClass(): void
{
    $output = Tools::toPascalCase(Config::get('output'));
    $outputClass = self::OUTPUT_NAMESPACE.'\\'.$output;
    
    self::$output = $outputClass;
}

Define o nome da classe referente ao formato de saída, concatenado ao namespace padrão das classes de formato de saída.

• PARÂMETROS:

  Este método não possui parâmetros.

• RETORNO:

  Este método não retorna dados.

• EXPLICAÇÃO:

  O namespace das classes de saída deve ser fornecido como uma string. Isso ocorre porque, no PHP, não é possível atribuir uma classe de forma dinâmica utilizando o termo use no início do arquivo.

________________

setControllerNamespace()

private static function setControllerNamespace(): void
{
    self::$controllerNamespace = implode('\\', Router::getControllerNamespace());

    if (!class_exists(self::$controllerNamespace)) {
        $controllerLocation = implode('/', Tools::deleteLastKey(Router::getControllerNamespace()));

        if (self::$output::requiresController()) {
            throw new Exception(
                Message::get("CONTROLLER_NOT_FOUND"),
                [
                    self::$controllerNamespace,
                    $controllerLocation,
                ]
            );
        }

        self::$controllerExists = false;

    } elseif (!is_subclass_of(self::$controllerNamespace, self::MODULE_CONTROLLER)) {

        throw new Exception(
            Message::get("CONTROLLER_MUST_EXTEND_MODULE"),
            [
                self::$controllerNamespace,
            ]
        );
    }
}

Este método define o namespace e a classe que será usada como controller da execução. Ele realiza uma série de verificações para garantir que a classe controller seja válida.

• PARÂMETROS:

  Este método não possui parâmetros.

• RETORNO:

  Este método não retorna dados.

• EXPLICAÇÃO:

  • Verificação de Existência da Classe: Caso a classe não exista e o formato de saída requeira obrigatoriamente uma classe controller, uma exceção será lançada. Se não for obrigatório, a propriedade $controllerExists será marcada como false.

  • Verificação de Herança: Se a classe controller existir, é verificado se ela é uma subclasse do módulo controller principal definido pela constante MODULE_CONTROLLER. Caso não seja, uma exceção será gerada.

________________

setMethodName()

private static function setMethodName(): void
{
    if (!self::controllerExists()) {
        self::$controllerMethodExists = false;
        return;
    }

    self::$controllerMethodName = Router::getMethodName();
    
    if(!method_exists(self::$controllerNamespace, self::$controllerMethodName)) {
    
        throw new Exception(
            Message::get("CONTROLLER_METHOD_NOT_FOUND"),
            [
                self::$controllerNamespace,
                self::$controllerMethodName.'()',
            ]
        );
    }
}

Este método define o nome do método da controller que será executado, com base na configuração da rota. Ele também realiza uma verificação para garantir que o método exista na classe controller.

• PARÂMETROS:

  Este método não possui parâmetros.

• RETORNO:

  Este método não retorna dados.

• EXPLICAÇÃO:

  • O método só será definido caso exista uma controller. Se a classe controller não existir, a propriedade $controllerMethodExists será configurada como false.

    • É importante ressaltar que isso pressupõe que a controller não é obrigatória para o formato de saída, pois a propriedade $controllerExists só é false quando o controller for opcional.

  • Caso o método não seja encontrado na controller, uma exceção será lançada com uma mensagem personalizada, informando o nome da classe e do método não encontrado.

________________

setHttpMethodName()

private static function setHttpMethodName(): void
{
    if (!self::controllerExists()) {
        return;
    }

    $httpMethodList = Config::get('httpMethod');
    $serverHttpMethod = mb_strtolower($_SERVER['REQUEST_METHOD']);

    if (!empty($httpMethodList) and array_key_exists($serverHttpMethod, $httpMethodList)) {

        self::$controllerHttpMethodName = $httpMethodList[$serverHttpMethod];
        self::$controllerHttpMethodExists = true;

        if(!method_exists(self::$controllerNamespace, self::$controllerHttpMethodName)) {
            throw new Exception(
                Message::get("CONTROLLER_METHOD_NOT_FOUND"),
                [
                    self::$controllerNamespace,
                    self::$controllerHttpMethodName.'()',
                ]
            );
        }
    }
}

Este método define o nome do método da controller que será executado com base no tipo de requisição HTTP definido na configuração da rota. Ele também realiza uma verificação para garantir que o método exista na classe controller.

• PARÂMETROS:

  Este método não possui parâmetros.

• RETORNO:

  Este método não retorna dados.

• EXPLICAÇÃO:

  • O método só será definido caso exista uma controller.

  • Se houverem métodos definidos para requisição HTTP, é verificado se a requisição atual corresponde a um destes métodos. Caso sim, então seu nome é definido.

  • Caso o método não seja encontrado na controller, uma exceção será lançada com uma mensagem personalizada, informando o nome da classe e do método não encontrado.

________________

executeController()

private static function executeController(): void
{
    self::$controller = new self::$controllerNamespace();
}

Cria a instância da controller (que irá executar os métodos logo que for estanciada);

• PARÂMETROS:

  Este método não possui parâmetros.

• RETORNO:

  Este método não retorna dados.

________________

controllerExists()

public static function controllerExists(): bool
{
    return self::$controllerExists;
}

• PARÂMETROS:

  Este método não possui parâmetros.

• RETORNO:

  Retorna true caso a classe controller existir ou false caso não.

________________

methodExists()

public static function methodExists(): bool
{
    return self::$controllerMethodExists;
}

• PARÂMETROS:

  Este método não possui parâmetros.

• RETORNO:

  Retorna true caso o método da classe controller existir ou false caso não.

________________

httpMethodExists()

public static function httpMethodExists(): bool
{
    return self::$controllerHttpMethodExists;
}

• PARÂMETROS:

  Este método não possui parâmetros.

• RETORNO:

  Retorna true caso o método da requisição HTTP da classe controller existir ou false caso não.

________________

getControllerResponse()

public static function getControllerResponse(): array
{
    return self::$controller->getResponse();
}

• PARÂMETROS:

  Este método não possui parâmetros.

• RETORNO:

  Retorna um array contendo a resposta do método da controller.

________________

getControllerFileContents()

public static function getControllerFileContents(): array
{
    return self::$controller->getFileContents();
}

• PARÂMETROS:

  Este método não possui parâmetros.

• RETORNO:

  Retorna um array contendo o conteúdo de um arquivo gerado ou importado dinamicamente para a controller.

________________

executeOutput()

private static function executeOutput(): void
{
    self::$output::run();
}

Executa o método principal do formato de saída.

• PARÂMETROS:

  Este método não possui parâmetros.

• RETORNO:

  Este método não retorna dados.

________________

getControllerNamespace()

public static function getControllerNamespace(): string
{
    return self::$controllerNamespace;
}

• PARÂMETROS:

  Este método não possui parâmetros.

• RETORNO:

  Retorna uma string contendo o namespace para a controller.

________________

getControllerMethodName()

public static function getControllerMethodName(): string
{
    return self::$controllerMethodName;
}

• PARÂMETROS:

  Este método não possui parâmetros.

• RETORNO:

  Retorna uma string contendo o nome do método da controller.

________________

getControllerHttpMethodName()

public static function getControllerHttpMethodName(): string
{
    return self::$controllerHttpMethodName;
}

• PARÂMETROS:

  Este método não possui parâmetros.

• RETORNO:

  Retorna uma string contendo o nome do método da requisição HTTP da controller.