dejframework
1.0.0
Uma estrutura leve e fácil de usar.
O DEJFramework é uma estrutura simples e mínima de MVC do PHP, focada na concisão, simplicidade e compreensibilidade. Sua sintaxe é inspirada principalmente em Laravel. Dejframework foi desenvolvido pela Ata Marzban para o projeto final do Bacharelado.
#Instalação
composer install no diretório raiz.Para que a estrutura saiba o que fazer quando for uma solicitação, você deve definir rotas para seus aplicativos em /pp/routes.php. É feito facilmente.
Uma rota consiste em um método HTTP, URL e o destino que deve ser executado se uma solicitação for feita com o método especificado para o URL especificado. Nada é executado sem definir rotas. Você pode passar um fechamento como destino:
[/app/routes.php]
Route:: set ( " GET " , " / " , function (){
return " Hello World! " ;
});Este código será lançado "Hello World" se você visitar o seu site no Yoursite.com.
[/app/routes.php]
Route:: set ( " GET " , " /some/url " , function (){
return " This is some url! " ;
});Este código será lançado "Este é um URL!" Se você visitar seu site em seu mite.com/some/url.
[/app/routes.php]
Route:: set ( " POST " , " /do/something " , function (){
return " Here you should write your own code to do the things you want. " ;
});Este código será executado se você visitar seu mite.com/do/something com o método de postagem. (de um formulário ou chamada de API)
Você pode devolver strings, objetos, matrizes ou visualizações (discutidos posteriormente) em seus fechamentos ou controladores. A String será emitida diretamente, enquanto objetos ou visualizações serão convertidos automaticamente em JSON e saída, e as visualizações serão renderizadas para a saída.
Na próxima parte, você aprenderá a direcionar rotas para os controladores em vez de fechamentos.
É considerado uma prática recomendada no padrão MVC que a lógica do aplicativo deve ser colocada em controladores.
[/app/controllers/YourController.php]
<?php
namespace app controllers;
class YourController extends dej mvc Controller
{
public static function yourAction ()
{
return " This is the right way to do it! " ;
}
}IMPORTANTE: Como você pode ver no exemplo acima, para o AutoLoader do PSR-0 funcionar corretamente, você deve seguir as seguintes convenções ao adicionar qualquer classe ao seu aplicativo:
Agora vamos continuar aprendendo a fazer os controladores funcionarem:
[/app/routes.php]
Route:: set ( " GET " , " / " , " YourController@YourAction " );A ação especificada no controlador especificada será executada quando a rota acionar.
Instantando constantemente aulas e passando dependências para elas podem se tornar uma tarefa repetitiva no desenvolvimento do PHP. O provedor de serviços de aplicativo DEJ pretende tornar esse processo o mais seco possível. Usando esse provedor de serviços, você não precisa adicionar instruções de uso em cada arquivo e passar dependências. Veja este exemplo:
/**
* Without a Service Provider
* when you want to build a query
*/
use dej db Connection ;
$ connection = Connection:: getInstance ();
use dej db Query ;
$ query = new Query ( $ connection );
$ result = $ query -> select ()-> from ( ' someTable ' )-> getAll ();
return $ result ;E isso deve ser repetido toda vez que você deseja usar o Consultor de Consultas. Agora, usando o provedor de serviços:
use dej App ;
return App:: Query ()-> select ()-> from ( ' some_table ' );É isso! Dê uma olhada no DEJ/APP.PHP para ver como ele funciona. Um método estático chamado 'consulta' é chamado na classe de aplicativo. Ele instancia a classe de consulta e passa uma instância de conexão como os parâmetros do construtor. Pedaço de bolo!
#Request A classe dejhttpRequest facilita a interação com a solicitação, veja um dos exemplos a seguir:
//check if request is ajax or not
$ result = App:: Request ()-> isAjax ();
//returns $_GET['name'];
$ result = App:: Request ()-> get ( ' name ' );
//returns $_POST['name'];
$ result = App:: Request ()-> post ( ' name ' );
//returns $_REQUEST;
$ result = App:: Request ()-> all (); #Response A classe dejhttpResponse facilita os parâmetros de resposta de configuração, você deve retornar uma resposta no seu controlador se desejar definir códigos de resposta ou cabeçalhos HTTP, consulte AA nos exemplos a seguir:
class IndexController extends dej mvc Controller
{
public static function index ()
{
return App:: Response ()-> code ( 404 )-> header ( ' HTTP/1.1 404 Not Found ' );
}
}Você pode redirecionar facilmente:
//in the controller
return App:: Response ()-> redirect ( ' /login ' );
//redirect with errors
App:: Response ()-> redirect ( ' / ' )-> withErrors ([ ' login ' => ' login unsuccessful! maybe password is wrong. ' ]);Redirecionar com erros pisca os erros para a sessão (discutido posteriormente).
Configuração: primeiro digite a configuração do banco de dados em /config.json . O DEJFramework lida com bancos de dados em uma arquitetura de 3 camadas:
Camada 1 - Objeto de conexão do banco de dados: estende a classe abstrata singleton. O que isso significa é que é instanciado apenas uma vez, a primeira vez que é chamada. Alguns outros serviços do DeJframework também são assim. Para evitar a sobrecarga de conectar -se ao banco de dados toda vez que você deseja executar uma consulta. Aqui está como você pode usá -lo:
//simple query
$ result = App:: Connection ()-> executeQuery ( " SELECT * FROM some_table " );
//NonQuery: a query that doesn't return rows, only the number of affected rows.
$ result = App:: Connection ()-> executeNonQuery ( " DELETE FROM some_table WHERE some_field = 'some_value' " );
//A Query using prepared statements, To protect against SQL Injection.
$ result = App:: Connection ()-> executeQuery ( " SELECT * FROM some_table WHERE some_field = ? " , [ " some_value " ]);
//A Query using prepared statements, To protect against SQL Injection. With Multiple Parameters.
$ result = App:: Connection ()-> executeQuery ( " SELECT * FROM some_table WHERE some_field = ? AND another_field = ? " , [ $ some_value , " another_value " ]);
//A Query using prepared statements, To protect against SQL Injection. With Named Parameters.
$ result = App:: Connection ()-> executeQuery ( " SELECT * FROM some_table WHERE some_field = :some_value_name
AND another_field = :another_value_name " ,
[ " :some_value_name " => $ some_value ,
" another_value_name " => " another_value " ]); Você pode fazer isso em qualquer lugar, desde que tenha adicionado use dejApp; .
Camada 2 - Construtor de consultas: Esta classe cria consultas e usa a classe de conexão para executá -las usando declarações preparadas seguras. Ele deve ser instanciado para cada nova consulta, isso é feito para você por /dej /aplicativo automaticamente sempre que você digita App::Query() , assim como vimos no exemplo da seção de serviço do Povider. Você pode criar consultas com ele usando o encadeamento do método. Dê uma olhada nos exemplos abaixo:
$ result = App:: Query ()-> select ()-> from ( ' users ' )-> getAll ();
$ result = App:: Query ()-> select ()-> from ( ' users ' )-> getOne ();
$ result = App:: Query ()-> select ()-> from ( ' users ' )-> getJson ();
$ query = App:: Query ()-> select ()-> from ( ' users ' )-> getQuery (); As you can see, using the dej Query Builder is simple, use call App::Query() and it automatically passes a new, dependency injected Query class to you, and then you chain methods on it to add conditions of your liking to it, such as select(), from() and so on, then finally, you use one of the get methods to fetch either the top result ( getOne() ), All results ( getAll() ), All results as JSON ( getJson() ), ou a consulta construída ( getQuery() ). Os resultados são buscados no formato STDClass que você pode usar facilmente. Vale a pena notar que, sem usar um dos métodos GET no final de você, os resultados não serão buscados. Além disso, você pode encadear métodos em várias linhas e em várias etapas, por exemplo, para alterá -lo por alguma condição:
$ query = App:: Query ()-> select ();
if ( $ somecondition == true ) $ query -> from ( ' users ' );
else $ query -> from ( ' another_table ' );
$ result = $ query -> getAll ();Vamos ver outros métodos disponíveis no construtor de consultas nos exemplos a seguir:
//All queries will be executed using prepared statements and parameters will be handled automatically.
//SELECT Queries:
$ result = App:: Query ()-> select ()-> from ( ' users ' )-> where ( ' id ' , ' = ' , ' 22 ' )-> getAll ();
//you can omit the operator and it uses '=' by default
$ result = App:: Query ()-> select ()-> from ( ' users ' )-> where ( ' id ' , ' 22 ' )-> getAll ();
$ result = App:: Query ()-> select ()-> from ( ' users ' )-> where ( ' city ' , ' = ' , ' Berlin ' )
-> andWhere ( ' age ' , ' > ' , ' 20 ' )-> getAll ();
$ result = App:: Query ()-> select ()-> from ( ' users ' )-> where ( ' city ' , ' = ' , ' Berlin ' )
-> orWhere ( ' city ' , ' = ' , ' Paris ' )-> getAll ();
$ result = App:: Query ()-> select ()-> from ( ' users ' )-> orderBy ( ' age ' , ' DESC ' )
-> limit ( 25 )
-> offset ( 50 )-> getAll ();
//INSERT Query:
$ affectedRows = App:: Query ()-> insertInto ( ' users ' )-> values ([ " username " => " jameshetfield " ,
" password " => " 19831983 " ,
" city " => " Downey " ])-> execute (); Observe que as consultas que não retornam os resultados devem ser executadas com php execute() e retornarão automaticamente o número de linhas afetadas.
//UPDATE Query:
$ affectedRows = App:: Query ()-> update ( ' users ' )-> set ([ " age " => 53 ,
" band " => " Metallica " ])
-> where ( ' username ' , ' = ' , ' jameshetfield ' )-> execute ();
//DELETE Query:
$ affectedRows = App:: Query ()-> deleteFrom ( ' users ' )-> where ( ' username ' , ' = ' , ' someone ' )-> execute ();Observe que as consultas de exclusão ou atualização podem resultar em perda de dados, se não houver nenhuma cláusula fornecida, pois uma medida de segurança, o dejframework fará uma exceção se encontrar essa situação. Por favor, execute essas consultas usando a classe de conexão manualmente.
Camada 3 - Mapeamento Relacional de Objetos: ORM será discutido na próxima seção.
De acordo com a Wikipedia:
O mapeamento de objetos-relatórios (ORM) ... é uma técnica de programação para converter dados entre sistemas de tipos incompatíveis em linguagens de programação orientadas a objetos. Isso cria, na verdade, um "banco de dados de objetos virtuais" que pode ser usado na linguagem de programação.
Como o DEJFramework funciona em uma arquitetura MVC, a persistência de dados está contida no componente modelo do MVC. Os modelos estão relacionados às entidades do seu aplicativo, como um usuário, uma compra, um produto etc. em um sistema de compras. Eles precisam ser salvos e recuperados de e para o banco de dados. Os bancos de dados relacionais funcionam no idioma SQL e o dejframework, como a maioria das estruturas, opera em um ambiente orientado a objetos. E o código SQL no meio do código PHP é considerado não a melhor prática. Assim, Dejframework tenta separá -lo do código SQL em 3 níveis, 2 deles foram elaborados na seção anterior, agora veremos como trabalhar com modelos:
class User extends dej mvc Model
{
protected static $ dbTable = " users " ;
//Format: ["db_field_name" => "modelPropertyName"]
protected static $ primaryKey = [ " id " => " id " ];
//Model properties
public $ username ;
public $ password ;
public $ city ;
.
.
.
} class User extends dej mvc Model
{
protected static $ dbTable = " users " ;
//Format: ["db_field_name" => "modelPropertyName"]
protected static $ dbFields = [ " username " => " username " ,
" password " => " password " ,
" city " => " city " ,
" id " => " id " ];
public $ username ;
public $ password ;
public $ city ;
.
.
.
} Observe que a propriedade id é definida na classe /dej/mvc/Model que seus modelos estendem. Portanto, se você deseja que seu modelo tenha um ID, não há necessidade de defini -lo novamente.
class User extends dej mvc Model
{
protected static $ dbTable = " users " ;
protected static $ dbFields = [ " username " => " username " ,
" password " => " password " ,
" city " => " city " ,
" id " => " id " ];
//Exactly the same as the class name
protected static $ modelName = " User " ;
public $ username ;
public $ password ;
public $ city ;
.
.
.
}Por enquanto, é que você definiu essas configurações corretamente, você poderá usar os métodos ORM em seus modelos. Dê uma olhada nos exemplos abaixo:
//Creating a new record
use app models User ;
$ user = new User ();
$ user -> username = " jameshetfield " ;
$ user -> password = " 13831383 " ;
$ user -> city = " Downey " ;
$ user -> create (); //Saved into the database.
//or you can set the properties in the constructor
$ user = new User ([
' username ' => ' jameshetfield ' ,
' password ' => ' 13831383 ' ,
' city ' => ' Downey '
]);
$ user -> create ();O ORM usa o DeJ Consulta Builder por baixo, para gerar consultas necessárias.
Observe que as linhas Create (), Update () e Delete () retornam que você pode verificar se a operação foi bem -sucedida.
//Finding a record by a field named 'id'
$ user = User:: findById ( 11 );
//changing it's properties
$ user -> password = " through_the_never " ;
$ user -> update (); //Updated in the database.
//deleting it.
$ user -> delete ();Observe que essas funções funcionam com a chave primária dos registros.
//Finding records by some condition.
$ users = User:: find ()-> where ( ' city ' , ' = ' , ' Sari ' )-> getAll (); //Returns an array of User objects.
//A more complex one
$ users = User:: find ()-> where ( ' city ' , ' = ' , ' Sari ' )-> andWhere ( ' age ' , ' > ' , 20 )-> orderBy ( ' age ' , ' ASC ' )
-> limit ( 25 )
-> offset ( 100 )-> getAll ();
//Don't forget the get*() method!
//Retrieveing all records
$ users = User:: getAll (); //doesn't need a getAll() at the end because it knows what to do.
//The method for deleting by condition is named 'wipe'
$ users = User:: wipe ()-> where ( ' status ' , ' = ' , ' banned ' )-> orWhere ( ' email_confirmation ' , ' = ' , ' 0 ' )-> execute ();
//counting all records
$ userCount = User:: countAll ();
//counting records that have a certain condition
$ userCount = User:: count ()-> where ( ' city ' , ' = ' , ' Sari ' )-> getInt (); //getInt() returns the count of the results as an Integer. A validação de dados no dejframework é tratada pela classe dejValidator . Você pode usá -lo de várias maneiras:
App::Validator() , que fornece a instância de singleton. Ele aceita 2 parâmetros: um valor a ser validado. (String, int, Array, Objeto) e um conjunto de regras para validar os dados contra.Vamos ver como funciona:
use dej App ;
//Validate a single value according to a set of rules seperated by "|".
$ result = App:: Validator ()-> validate ( " This is going to be validated " , " required|string|min:5|max:30 " );
//Validate an object or and array:
$ result = App:: Validator ()-> validate ( $ user , [ ' username ' => ' required|string|email|min:5|max:30 ' ,
' password ' => ' required|string|min:10|max:100 ' ],
' age ' => ' int|min:18|max:99 ' ); O método validate() retorna uma matriz. Se não houver erros de validação e os dados forem válidos, serão uma matriz vazia. para que você possa verificar se os dados são válidos com empty() . Se houver algum erro de validação, você os verá na matriz.
//The rules have changed
$ errors = App:: Validator ()-> validate ( " This is going to be validated " , " required|string|email|min:5|max:10 " );
var_dump ( $ errors );É isso que o código acima será lançado:
array
0 => 'This Field should be an email'
1 => 'This Field should be less than 10'
Agora com um objeto:
$ errors = App:: Validator ()-> validate ( $ obj , [ ' email ' => ' required|string|email ' ,
' password ' => ' required|string ' ,
' age ' => ' int ' ]);
var_dump ( $ errors );Saída:
array (size=3)
'email' =>
array (size=1)
0 => string 'This Field should be an email'
'password' =>
array (size=2)
0 => string 'This Field is Required'
1 => string 'This Field should be more than 10'
'age' =>
array (size=1)
0 => string 'This Field should be a number'
Como você pode ver, se você passar um objeto ou matriz para o validador, ele retornará os erros relacionados a cada campo em uma matriz associativa, onde as chaves são nomes de campo e os valores são matrizes contendo erros relacionados a esse campo.
validate() no objeto Solicitação. $ errors = App:: Request ()-> validate ([ ' email ' => ' required|string|email ' ,
' password ' => ' required|string|min:10|max:100 ' ]);
var_dump ( $ errors ); Visitando yoursite.local/?email=notanemail&password=123 resultará em:
array (size=2)
'email' =>
array (size=1)
0 => string 'This Field should be an email'
'password' =>
array (size=1)
0 => string 'This Field should be more than 10'
/app/models/User.php : class User extends dej mvc Model
{
.
.
.
protected static $ validationRules = [ " username " => " required|string|min:5|max:20 " ,
" password " => " required|string|min:5|max:255 " ,
" city " => " string|max:10 " ];
.
.
.
}Agora você pode validar instâncias dos modelos:
$ user = User:: getById ( 11 );
$ errors = $ user -> validate (); //returns errors in array like the previous examples.
$ isValid = $ user -> isValid (); //returns true or falseQuando você tem seus erros, pode passar para a visão para exibir ou redirecionar para algum lugar com eles:
//in the controller
$ errors = $ user -> validate ();
if (! empty ( $ errors )) return App:: Response ()-> redirect ( ' / ' )-> withErrors ( $ errors ); As mensagens de validação que você viu nos exemplos anteriores foram mensagens padrão, e se você quiser alterá -las ou ter mensagens de validação em seu próprio idioma? Dê uma olhada em /app/locale/en/validation/messages.php :
return [
" required " => " This Field is Required " ,
" string " => " This Field should be an string " ,
" int " => " This Field should be a number " ,
" min " => " This Field should be more than %s " ,
" max " => " This Field should be less than %s " ,
" email " => " This Field should be an email " ,
]; Você pode ver que a chave corresponde ao tipo de validação e os valores são mensagens de validação. As variáveis estão incluídas nas mensagens com 's'. In /app/locale , você pode criar seu próprio diretório para o idioma de sua escolha e nesse diretório, ter suas próprias mensagens de validação com variáveis.
Você pode definir a localidade padrão em /config.json .
Você pode alterá-lo no seu aplicativo por App::Config()->locale = 'your_locale';
Para trabalhar com a sessão PHP, o DEJFramework fornece a classe dejSession . Aqui estão alguns exemplos de como usá -lo:
//to set session variables
App:: Session ()-> save ([
' key1 ' => ' value1 ' ,
' key2 ' => ' value2 '
]);
//to get session variables
$ value1 = App:: Session ()-> get ( ' key1 ' );
//to regenerate session id
App:: session ()-> regenerateId ();
//get all session variables as associative array
$ wholeSession = App:: session ()-> all ();
//destroy the session
App:: session ()-> destroy ();
//delete a variable
App:: session ()-> delete ( ' key1 ' );
//see if variable is set
$ trueOrFalse = App:: session ()-> isSaved ( ' key1 ' );Se você deseja que uma variável de sessão esteja disponível apenas na próxima solicitação, por exemplo, uma determinada mensagem de erro, você pode exibi -la para a sessão como esta:
App:: session ()-> flash ([ ' message ' => ' Registered Successfully! ' ]);E recuperá -lo no próximo pedido:
$ message = App:: session ()-> getFlash ( ' message ' ); Observe que as mensagens flash estão disponíveis apenas na próxima solicitação e somente com ->getFlash() .
Você pode definir a sessão para expirar após um tempo definido desde o último acesso à sessão:
App:: Session ()-> save ([ ' key ' => ' value ' ]);
App:: Session ()-> lifeTime ( 60 ); //session will expire after 60 seconds since last access to the session. (last use of App::Session())Às vezes, você pode querer que seu aplicativo se lembre de uma instância de um modelo para as próximas solicitações. Por exemplo, você deseja que o aplicativo se lembre do usuário que está conectado, ou o carrinho de compras que seu usuário tem, ou qualquer outra coisa. Se você armazenar a chave primária do modelo que deseja na sessão e executar uma consulta para recuperá -la em todas as solicitações, poderá ser tedioso. O DEJFramework resolve isso, fornecendo uma característica que você pode usar em seus modelos. Dê uma olhada:
class ShoppingCart extends dej mvc Model
{
use dej traits IsStateful;
.
.
.
}Agora você tem mais alguns métodos disponíveis em seu modelo:
//suppose you want to create a shopping cart for a guest user and add a product to it:
$ cart = new ShoppingCart ();
$ cart -> addProduct ( 2389 );
$ cart -> create (); //stored in the db
//if you want to save it to the session get it easily in the next request
$ cart -> remember ( ' guest_shopping_cart ' ); //provide a key to remember it by this key.Agora, no próximo pedido:
if (ShoppingCart:: isRemembered ( ' guest_shopping_cart ' )) //see if theres any cart in the session
$ cart = ShoppingCart:: retrieve ( ' users_shopping_cart ' ); //get's fresh data from the db
if (ShoppingCart:: hasChanged ( ' guest_shopping_cart ' ))
{
//checks if the cart in the database has changed **since you saved the cart in the session**.
doSomeThing ();
}
ShoppingCart:: forget ( ' guest_shopping_cart ' ); //forgets the cart. Para apresentar seus dados ao usuário, você precisa de uma interface do usuário. Na web, na maioria das vezes isso significa marcação HTML. No MVC, a lógica deve ser separada da interface do usuário, para que você coloque seu HTML em visualizações e inclua apenas a lógica de apresentação nelas, como echo um valor ou colocando uma matriz em um `` `foreach` 'para iterar sobre ele. Para criar uma visão que você deve:
/app/views . Há uma visão incluída por padrão: index.phtml <!DOCTYPE html >
< html >
< head >
< title > < ?= $data- > user- > username ? > 's profile </ title >
</ head >
< body >
< h2 > View < ?= $data- > user- > username ? > 's Profile </ h2 >
< p > Username: < ?= $data- > user- > username ? > </ p >
< p > Password: < ?= $data- > user- > password ? > </ p >
< p > City: < ?= $data- > user- > city ? > </ p >
</ body >
</ html > class IndexController extends dej mvc Controller
{
public static function index()
{
$ user = User:: find ()-> where ( ' username ' , ' = ' , ' jameshetfield ' )-> getOne ();
return App:: View ( ' user ' , [ ' user ' => $ user ]); //the first argument is the view name,
the second one is the data you want to pass to
the view, in this example, a variable called ' user '
will be available in the user.phtml view
which contains the instance of user we fetched.
Piece of cake!
}
}Você também pode fornecer mensagens de erro:
//in the controller
return App:: View ( ' user ' )-> withErrors ([ ' authorization ' => ' You are not allowed to view this user. ' ]);A estrutura renderizará a visão da saída e o resultado será:
<!DOCTYPE html >
< html >
< head >
< title > jameshetfield's profile </ title >
</ head >
< body >
<!-- access the errors like this: -->
< span class =" error " > < ?= $this- > errors('authorization') ? > </ span >
< h2 > View jameshetfield's Profile </ h2 >
< p > Username: jameshetfield </ p >
< p > Password: 13831383 </ p >
< p > City: Downey </ p >
</ body >
</ html >Agora vamos ver outro exemplo, e se queremos criar uma tabela de todos os usuários? Edite sua visão:
<!DOCTYPE html >
< html >
< head >
< title > All Users </ title >
</ head >
< body >
< table >
< tr >
< th > username </ th >
< th > password </ th >
< th > city </ th >
</ tr >
< ?php foreach ($data- > users as $user): ? >
< tr >
< th > < ?= $user- > username ? > </ th >
< th > < ?= $user- > password ? > </ th >
< th > < ?= $user- > city ? > </ th >
</ tr >
< ?php endforeach; ? >
</ table >
</ body >
</ html >E então seu controlador:
class IndexController extends dej mvc Controller
{
public static function index ()
{
$ users = User:: getAll ();
return App:: View ( ' user ' , [ ' users ' => $ users ]);
}
}E veja o resultado por si mesmo!
Você pode criar visualizar parciais e colar (incluí -los) em outras visualizações:
[/app/views/partials/header.phtml]
<!--begin header-->
<!DOCTYPE html >
< html >
< head >
< meta charset =" UTF-8 " >
< title > < ?= $data- > title ? > </ title >
</ head >
< body >
<!--end header--> e cole em index.phtml :
[/app/views/index.phtml]
< ?php $this- > paste('partials/header'); ? >
< h2 > < ?= $data- > message ? > </ h2 >
.
.
.
</ html > Autenticação é uma matéria relacionada ao aplicativo. Ele pode ser muito diferente em todos os aplicativos, portanto, o DeJframework não o implementa na estrutura em si; em vez disso, você recebe o modelo básico de usuário, rotas de autenticação e lógica do controlador que faz com que a autenticação aconteça e você é livre para alterá-lo ou implementar sua própria solução, a solução que é implementada na estrutura usa a IsStateful o modelo de usuário e $user->remember() . A única coisa que você precisa fazer é definir 'default_auth_model' em config.json para poder usar App::Request->user() para ::retrieve() o usuário da sessão usando a característica IsStateful .
Dê uma olhada no controlador, modelo e visualizações que são fornecidas na estrutura de autenticação para entender seus funcionamentos. e alterar/melhorar/removê -lo como quiser.
Nota: Para que o modelo de usuário funcione corretamente, você precisa criar uma tabela chamada users com 2 campos:
TABLE: users
FIELD TYPE
id int, autoincrement
username varchar
password varchar(255) //password hashing system requires 255
