Refletindo o uso de URLs amigáveis no Adianti

Guilherme Faht 31/01/2015 (há 9 anos)

O Adianti Framework foi concebido para auxiliar no desenvolvimento de sistemas em PHP. Justificado por essa questão, o uso de URLs amigáveis nunca foi o objetivo do Framework. Porém, recentemente a comunidade tem aumentado a pressão para o seu uso. Aproveitando esse momento, julgou-se como pertinente publicar esse artigo utilizando como base um estudo feito por esse autor ano passado (2014).

Durante o desenvolvimento de um sistema a equipe está focada principalmente nas regras de negócio. Após o sistema ficar pronto a equipe começa a ver os problemas: A falta de usabilidade e o fluxo de navegação (foco desse artigo). A questão de usabilidade vai de como foi arquitetado o sistema, já o fluxo de navegação depende da redundância de navegação (várias formas de chegar ao mesmo ponto), do número de etapas a serem seguidas para resolver um problema, e finalmente as URLs. As URLs, como o próprio nome já diz, são a forma de localizar recursos na web. Isso significa que os recursos do seu sistema vão ser localizados através dela. Então, pensar em URLs amigáveis é importante sim.

Existem casos em que áreas do sistema não apresentam restrição de acesso. O usuário vai acessar essa parte do sistema como se fosse um site. Provavelmente essa parte do sistema será uma descrição do que se trata o sistema, poderá ser uma área onde são exibidos os planos que poderão ser contratados, ou quem sabe uma área onde o usuário poderá cria a sua conta. Não importa, qualquer sistema terá uma área sem restrição. A questão é: Como ocorrem os acessos a essas áreas? Via URL! Então devemos tratar elas de forma mais interessante do que abusar de query strings.

Como já foi descrito acima, esses são resultados de um estudo de 2014, válido apenas para as versões 1.02 e 1.03. Durante a execução desse estudo foram alterados todos os arquivos que tratam a leitura de query strings, além disso, foi criada uma classe para efetuar a decodificação das URLs amigáveis. Concluído o estudo, foi possível desenvolver sistemas usando URLs amigáveis no Adianti Framework.
As URLs seguiram o padrão: www.sistema.com.br/controller/método/var/var/var. Além de permitir a associação de chave/valor, podendo a URL assumir a seguinte configuração: www.sistema.com.br/controller/método/key/var/key/var. Para atingir esse resultado, foi necessário alterar a classe TCoreApplication e nela instanciou-se a classe decodificadora de ULs amigáveis, para então essa retornar os dados que a TCoreApplication necessita. O resultado pode ser observado no trecho de código abaixo:

<php
class TCoreApplication
{
public static function run($debug = FALSE)
{
// get TURI instance;
$turi = TURI::getInstance();

$class = $turi->getClass() ? $turi->getClass() : 'meus-clientes';
$static = isset($_REQUEST['static']) ? $_REQUEST['static'] : '';
$method = $turi->getMethod() ? $turi->getMethod() : '';
$vars = $turi->getVars();
?>

Nota-se que primeiramente é pego uma instância de TURI, e em seguida, são passadas as informações que a TCoreApplication necessita para operação. Abaixo pode ser observado o código da classe TURI.

<?php
/**
* TURI utility class
* @author Guilherme Faht <guilherme [at] catcom.com.br>
* @version 1.0, 2014-02-23
*/
class TURI
{
private static $instance;
private $uri_string;
private $segments = array();
/**
* Construtor.
*/
private function __construct(){}
/**
* Método detect_uri()
* Faz a detecção do uri correto.
*/
private function detect_uri()
{
if ( ! isset($_SERVER['REQUEST_URI']) OR ! isset($_SERVER['SCRIPT_NAME']))
{
return '';
}
$uri = $_SERVER['REQUEST_URI'];
if (strpos($uri, $_SERVER['SCRIPT_NAME']) === 0)
{
$uri = substr($uri, strlen($_SERVER['SCRIPT_NAME']));
}
elseif (strpos($uri, dirname($_SERVER['SCRIPT_NAME'])) === 0)
{
$uri = substr($uri, strlen(dirname($_SERVER['SCRIPT_NAME'])));
}
if (strncmp($uri, '?/', 2) === 0)
{
$uri = substr($uri, 2);
}
$parts = preg_split('#\?#i', $uri, 2);
$uri = $parts[0];
if (isset($parts[1]))
{
$_SERVER['QUERY_STRING'] = $parts[1];
parse_str($_SERVER['QUERY_STRING'], $_GET);
}
else
{
$_SERVER['QUERY_STRING'] = '';
$_GET = array();
}
if ($uri == '/' || empty($uri))
{
return '/';
}
$uri = parse_url($uri, PHP_URL_PATH);
return str_replace(array('//', '../'), '/', trim($uri, '/'));
}
/**
* Método filter_uri()
* Filtra a uri.
*/
private function filter_uri($str)
{
if ($str != '')
{
if ( ! preg_match("|^[".str_replace(array('\\-', '\-'), '-', preg_quote('a-z 0-9~%.:_\-', '-'))."]+$|i", $str))
{
trigger_error('Caracteres inválidos na uri.');
}
}
$bad = array('$', '(', ')', '%28', '%29');
$good = array('$', '(', ')', '(', ')');
return str_replace($bad, $good, $str);
}
/**
* Método getInstance()
* Retorna a instância de TURI.
*/
public static function getInstance()
{
if(!self::$instance){
self::$instance = new TURI();
self::$instance->explode_segments();
}
return self::$instance;
}
/**
* Método explode_segments()
* Popula os segmentos disponíveis.
*/
private function explode_segments()
{
foreach (explode("/", preg_replace("|/*(.+?)/*$|", "\\1", $this->getURI())) as $val)
{
$val = trim($this->filter_uri($val));
if ($val != '')
{
$this->segments[] = $val;
}
}
}
/**
* Método getURI()
* Retorna a URI.
*/
public function getURI()
{
if(!$this->uri_string)
{
$this->uri_string = $this->detect_uri();
}
return $this->uri_string;
}
/**
* Método getClass
* Retorna a classe invocada.
*/
public function getClass(){
// Rotas disponíveis.
$routes = array(
'cadastro-cliente' => 'ClienteForm',
'listagem-cliente' => 'ClienteList',
'relatorio-cliente' => 'ClienteReport'
);
if(isset($this->segments[0])){
if(isset($routes[$this->segments[0]]))
{
return $routes[$this->segments[0]];
}
return $this->segments[0];
}
return NULL;
}
/**
* Método getMethod()
* Retorna o método a ser invocado.
*/
public function getMethod(){
if(isset($this->segments[1])){
return $this->segments[1];
}
return NULL;
}
/**
* Método getVars()
* Retorna o array de variáveis.
*/
public function getVars(){
if(count($this->segments) >= 3){
$segments = $this->segments;
array_shift($segments);
array_shift($segments);
$vars = array();
for($i=0; $i<count($segments); $i++){
if(isset($segments[$i+1])){
$vars[$segments[$i]] = $segments[$i+1];
$i++;
} else {
array_push($vars,$segments[$i]);
}
}
return $vars;
}
return NULL;
}
}
?>

Além da criação da classe TURI, foi necessário fazer profundas alterações na classe TAction e na Classe TDataGridAction, pois essas precisaram gerar requisições via URLs amigáveis conforme o padrão descrito acima.
Sendo assim, foi o objetivo desse artigo permitir uma melhor aplicação de URLs amigáveis usando o Adianti Framework. Qualquer dúvida ou sugestão fique a vontade em expressar a sua opinião. Afinal, criticas e sugestões são os recursos para propiciar mudanças.

Comentários (2)