Slim CRUD
1.0.0
A maneira de instalar o Slim recomendada por seus desenvolvedores é através do compositor PHP.
Se você usar uma distribuição como o Arch Linux ou com base nisso, o Composer estará nos repositórios oficiais, para que você possa instalá -lo com o Pacman.
# pacman -S composer
Caso não, para instalar o compositor grava no console, o seguinte comando:
$ curl -sS https://getcomposer.org/installer | sudo php -- --install-dir=/usr/local/bin --filename=composer
Ou, se preferir, você pode usar o seguinte script 2 :
#! /bin/sh
EXPECTED_SIGNATURE= $( wget https://composer.github.io/installer.sig -O - -q )
php -r " copy('https://getcomposer.org/installer', 'composer-setup.php'); "
ACTUAL_SIGNATURE= $( php -r " echo hash_file('SHA384', 'composer-setup.php'); " )
if [ " $EXPECTED_SIGNATURE " = " $ACTUAL_SIGNATURE " ]
then
php composer-setup.php --quiet
RESULT= $?
rm composer-setup.php
exit $RESULT
else
>&2 echo ' ERROR: Invalid installer signature '
rm composer-setup.php
exit 1
fi
Salvo como install-composer.sh para executá-lo no terminal com o comando
$ sh install-composer.sh
Nota : Através deste método, podemos manter o compositor atualizado, mas você deve mover o arquivo composer.phar para a pasta /usr/local/bin/ com o comando
# mv composer.phar /usr/local/bin/composer
Dessa maneira, você pode executar apenas compositor compositor com composer no console em vez de php <Directorio>composer.phar .
Se você é o usuário do Windows, deve baixar o Composer-Setup.*.exe do repositório oficial do compositor no Github, que está em https://github.com/composer/windows-setup/releases/ e siga as instruções que você fornece o instalador.
Podemos criar um projeto a partir do zero ou usar o esqueleto fornecido pelo Slim, o que nos dá uma configuração simples para iniciar o aplicativo, basta escrever o seguinte no console:
$ composer create-proyect slim/slim-skeleton crud-slim
Isso criará um novo diretório crud-slim com os arquivos necessários para começar a escrever o aplicativo.
Estrutura de diretório
crud-slim
├── composer.json
├── composer.lock
├── CONTRIBUTING.md
├── dirstruct.txt
├── logs
│ ├── app.log
│ └── README.md
├── phpunit.xml
├── public
│ └── index.php
├── README.md
├── src
│ ├── dependencies.php
│ ├── middleware.php
│ ├── routes.php
│ └── settings.php
├── templates
│ └── index.phtml
├── tests
│ └── Functional
│ ├── BaseTestCase.php
│ └── HomepageTest.php
└── vendor/...
Nota: O Conselho vendor/ contém muitos vice -diretor, mas não é recomendado editar nenhum dos arquivos contidos aqui, pois é onde todas as unidades usaremos no aplicativo e os modificarão afetariam a operação dele.
Se executarmos php -S localhost:8080 -t public public/index.php no diretório de nosso aplicativo e abrirá nosso navegador no localhost:8080 A seguinte visualização aparecerá
Criamos um banco de dados com o nome slim
$ mysql -u[nombre-de-usuario] -p
> CREATE DATABASE slim COLLATE = 'utf8_unicode_ci';
> u slim
Adicionamos a tabela usuarios .
> CREATE TABLE usuarios ( ` id ` BIGINT NOT NULL AUTO_INCREMENT,
` nombre ` VARCHAR ( 250 ) NOT NULL ,
` correo ` VARCHAR ( 250 ) NOT NULL ,
` clave_acceso ` VARCHAR ( 250 ) NOT NULL ,
PRIMARY KEY ( ` id ` ));Criamos o banco de dados que usaremos para o CRUD:
Criamos a tabela de usuários:
Agora que temos o banco de dados, devemos adicioná -lo à configuração Slim. Para isso, abrimos o arquivo settings.php localizado no diretório src e que contém o seguinte:
<?php
return [
' settings ' => [
' displayErrorDetails ' => true , // set to false in production
' addContentLengthHeader ' => false , // Allow the web server to send the content-length header
// Renderer settings
' renderer ' => [
' template_path ' => __DIR__ . ' /../templates/ ' ,
],
// Monolog settings
' logger ' => [
' name ' => ' slim-app ' ,
' path ' => __DIR__ . ' /../logs/app.log ' ,
' level ' => Monolog Logger:: DEBUG ,
],
],
];
Adicionamos após o campo logger a configuração do nosso banco de dados
//Configuración de base de datos para Slim
' db ' => [
' driver ' => ' mysql ' ,
' host ' => ' localhost ' ,
' database ' => ' slim '
'username' => '<tu nombre de usuario en mysql> ' ,
'password' => ' <tu contraseña> ' ,
'charset' => ' utf8',
' collation ' => ' utf8_unicode_ci ' ,
' prefix ' => '' ,
],
Além disso, para carregar automaticamente as classes que criaremos posteriormente, devemos adicionar o arquivo composer.json . Jon um mapeamento automático com a convenção PHP PSR-4 .
"autoload" : {
"psr-4" : {
"App\" : "src/"
}
} Agora você precisa criar o modelo de aplicativo. Embora o Slim não siga o padrão de design do MVC (controlador de model-vista) de maneira convencional, devemos ter um diretório exclusivo para cada componente, por isso criaremos um diretório para o modelo no src/ com nosso explorador de arquivos ou com o comando mkdir modelos a partir do diretório src .
Como sabemos, o SLIM não possui uma ferramenta para o mapeamento padrão-re-reboque de objetos. No entanto, nos permite adicionar uma de outra estrutura escrita no PHP; Nesse caso, usaremos 3 de Laravel.
Para adicionar eloqüentes ao nosso CRUD, devemos primeiro pedir ao compositor para adicioná -lo às dependências de nosso aplicativo.
$ composer require illuminate/database " ~5.1 " Em seguida, adicionamos eloqüentes ao recipiente de injeção de dependências (a seguir com CID ) do aplicativo. Abrimos o arquivo dependencies.php que está no diretório src e o adicionamos
$ container [ ' db ' ] = function ( $ container ) {
$ capsule = new Illuminate Database Capsule Manager ;
$ capsule -> addConnection ( $ container [ ' settings ' ][ ' db ' ]);
return $ capsule ;
}; Para inicializar eloqüentes no aplicativo, ele também deve ser adicionado ao public/index.php antes app->run();
$ capsule = $ app -> getContainer ()-> get ( ' capsule ' ); // toma el elemento capsule dentro del contenedor de la app
$ capsule -> bootEloquent (); // inicializa EloquentCriamos a classe modelless no Conselho de Administração.
<?php
namespace App Modelos ;
//importa Eloquent para usarlo en el modelo
use Illuminate Database Eloquent Model as Eloquent ;
n
class ModeloUsuario extends Eloquent
{
// Define la llave primaria de la tabla usuarios
protected $ primaryKey = ' id ' ;
// Define el nombre de la tabla
protected $ table = ' usuarios ' ;
// Define los campos que pueden llenarse en la tabla
protected $ fillable = [
' nombre ' ,
' correo ' ,
' clave_acceso ' ,
];
} Também criaremos um controladores no src para drivers de aplicativos. Depois que o diretório for criado, criaremos dentro dele uma classe de controlador útil que lidará com a operação do aplicativo. Além disso, como nossos controladores validarão, instalamos a ferramenta de validação de validação 4 através do Composer .
$ composer require respect/validation
<?php
namespace App Controladores ;
use App Modelos ModeloUsuario as Usuario ; // para usar el modelo de usuario
use Slim Views Twig ; // Las vistas de la aplicación
use Slim Router ; // Las rutas de la aplicación
use Respect Validation Validator as v ; // para usar el validador de Respect
/**
* Clase de controlador para el usuario de la aplicación
*/
class ControladorUsuario
{
// objeto de la clase Twig
protected $ view ;
// objeto de la clase Router
protected $ router ;
/**
* Constructor de la clase Controller
* @param type SlimViewsTwig $view - Vista
* @param type SlimRouter $router - Ruta
*/
public function __construct ( Twig $ view , Router $ router )
{
$ this -> view = $ view ;
$ this -> router = $ router ;
}
/**
* Verifica que los parametros que recibe el controlador sean correctos
* @param type array $args - los argumentos a evaluar
*/
public function validaArgs ( $ args )
{
$ valid = [
// verifica que la id sea un entero
v:: intVal ()-> validate ( $ args [ ' id ' ]),
// verifica que se reciba una cadena de al menos longitud 2
v:: stringType ()-> length ( 2 )-> validate ( $ args [ ' nombre ' ]),
// verifica que se reciba un correo
v:: email ()-> validate ( $ args [ ' correo ' ]),
// verifica que no esté en blanco la contraseña
v:: notBlank ()-> validate ( $ args [ ' clave_acceso ' ])
];
}
/**
* Verifica la correctud de un conjunto de validaciones
* @param type array $validaciones - el conjunto de validaciones a evaluar
* @throws Exception cuando las validaciones no están en un arreglo
*/
public static function verifica ( $ validaciones )
{
if (! is_array ( $ validaciones ){
throw new Exception ( ' Las validaciones deben estar en un arreglo ' );
} else {
foreach ( $ validaciones as $ v ){
if ( $ v == false ) {
return false ; // todas las validaciones deben cumplirse para que sea correcto
}
}
return true ;
}
}
/*-- Funciones del CRUD --*/
}Você também deve adicionar o usuário ao aplicativo do aplicativo para que ele possa usá -lo.
$ container [ ' ControladorUsuario ' ] = function ( $ container ){
return new App Controladores ControladorUsuario ( $ container );
}; Lembre -se de que, no Modelusuario, definimos uma peça preenchível para a tabela, isso ocorre porque, id definido no banco de dados como um atributo automático aumentado, então precisamos apenas entrar nos outros três campos no banco de dados e faremos isso com esta função:
/**
* Función para crear un usuario
* @param type SlimHttpRequest $request - solicitud http
* @param type SlimHttpResponse $response - respuesta http
*/
public function crea ( $ request , $ response , $ args )
{
/*
getParsedBody() toma los parametros del cuerpo de $request que estén
como json o xml y lo parsea de un modo que PHP lo entienda
*/
$ param = $ request -> getParsedBody ();
$ validaciones = $ this -> validaArgs ( $ param ); // hace las validaciones
if ( verifica ( $ validaciones )){
// evalua si el correo ya existe en la base de datos
$ correo_existente = Usuario:: where ( ' correo ' , $ atr [ ' correo ' ])-> get ()-> first ();
// si el correo ya existe manda un error 403
if ( $ correo_existente ){
echo -> $ this -> error ( ' YA_ESTÁ_REGISTRADO_EL_CORREO ' ,
$ request -> getUri ()-> getPath (),
404 );
return $ this -> response -> withStatus ( 403 );
} else {
//crea un nuevo usuario a partir del modelo
$ usuario = new Usuario ;
// asigna cada elemento del arreglo $atr con su columna en la tabla usuarios
$ usuario -> nombre = $ atr [ ' nombre ' ];
$ usuario -> correo = $ atr [ ' correo ' ];
$ usuario -> clave_acceso = $ atr [ ' clave_acceso ' ];
$ usuario -> save (); //guarda el usuario
// crea una ruta para el usuario con su id
$ path = $ request -> getUri ()-> getPath () . ' / ' . $ usuario -> id ;
return $ response -> withStatus ( 201 ); // el usuario fue creado con éxito
}
}
} Aqui, duas funções são exemplificadas, uma para mostrar todos os usuários registrados e outro onde um usuário específico mostra. A estrutura da lista.twig de modelos.twig e usuario.twig mencionados serão explicados em mais detalhes na seção de visualização.
/**
* Obtiene todos los usuarios de la tabla usuarios y los manda a la vista
* @param type SlimHttpRequest $request - solicitud http
* @param type SlimHttpResponse $response - respuesta http
*/
public function listaUsuarios ( $ request , $ response , $ args )
{
/*
la vista manda un arreglo de usuarios con la respuesta http,
para que lo renderice en en el template lista.twig
*/
return $ this -> view -> render ( $ response , ' lista.twig ' , [ ' usuarios ' => Usuario:: all ()]);
}
/**
* Busca un usuario por su id
* @param type SlimHttpRequest $request - la solicitud http
* @param type SlimHttpResponse $response - la respuesta http
* @param type array $args - argumentos para la función
*/
public function buscaUsuarioID( $ request , $ response , $ args )
{
$ id = $ args [ ' id ' ];
$ valid = [v:: intVal ()-> validate ( $ id )]; // verifica que la id sea un entero
n
// si la validación es correcta
if ( $ valid == true ){
$ usuario = Usuario:: find ( $ id ); // busca la id en la tabla usuarios
if ( $ usuario ){
/*
si el usuario es encontrado, manda una respuesta con éste
y lo renderiza en el template usuario.twig
*/
return $ this -> view -> render ( $ response , ' usuario.twig ' , $ usuario );
} else {
/*
Si no hay un usuario con la id de los parametros, entonces obtiene la uri de la solicitud,
redirecciona a la lista de usuarios y regresa una respuesta con la uri y un status 404 (not found)
*/
$ status = 404 ;
$ uri = $ request -> getUri ()-> withQuery ( '' )-> withPath ( $ this -> router -> pathFor ( ' listaUsuarios ' ));
return $ response -> withRedirect (( string ) $ uri , $ status );
} else {
// si la validación es falsa, regresa un error de bad request
return $ response -> withStatus ( 400 );
}
} Exemplo de uma função para atualizar um usuário.
/**
* Actualiza un usuario
* @param type SlimHttpRequest $request - la solicitud http
* @param type SlimHttpResponse $response - la respuesta http
* @param type array $args - argumentos para la función
*/
public function actualiza ( $ request , $ response , $ args )
{
// busca un usuario la id del arreglo de parametros en la tabla usuarios
$ usuario = Usuario:: find (( int ) $ args [ ' id ' ]);
if (! $ usuario ){
/*
Si no hay un usuario con la id de los parametros, entonces obtiene la uri de la solicitud,
redirecciona a la lista de usuarios y regresa una respuesta con la uri y un estado 404 (not found)
*/
$ status = 404 ;
$ uri = $ request -> getUri ()-> withQuery ( '' )-> withPath ( $ this -> router -> pathFor ( ' listaUsuarios ' ));
return $ response -> withRedirect (( string ) $ uri , $ status );
} else {
$ data = $ request -> getParsedBody (); // guarda los argumentos de la solicitud en un arreglo
$ validaciones = $ this -> valida ( $ data ); // valida los datos
if ( verifica ( $ validaciones )){
$ usuario -> update ( $ data ); // Eloquent actualiza la información en la tabla
// regresa una respuesta con la uri y redirecciona a la vista especifica del usuario
$ uri = $ request -> getUri ()-> withQuery ( '' )-> withPath ( $ this -> router -> pathFor ( ' usuario ' , [ ' id ' => $ usuario -> id ]));
return $ response -> withRedirect (( string ) $ uri );
}
}
} A Eloquent tem três maneiras de eliminar elementos de uma tabela: a primeira é eliminar uma instância do modelo do qual sua chave primária não é conhecida, ele usa a função delete , mas sua desvantagem é que você precisa recuperar toda a instância antes de chamar delete ; O segundo é que, assumindo que a chave primária do modelo é conhecida, chama a função destroy que elimina o modelo sem precisar recuperar a instância completa; A terceira opção é por consultas, por exemplo, $eliminados = Usuario::where('nombre','like','C%')->delete(); Eu eliminaria todos os usuários cujo nome começa com "C". Além disso, o eloqüente possui um ajuste suave , ou seja, o modelo não é excluído do banco de dados, mas um atributo deleted_at é adicionado e, conforme recomendado pelos desenvolvedores de Laravel, uma coluna deve ser adicionada à tabela para conter os referidos atributos. Para ativar o método de desostamento suave no aplicativo, você deve adicionar o IlluminateDatabaseEloquentSoftDeletes nos modelos de aplicativos. O exemplo a seguir usa delete para fazer validações e fornecer mais robustez antes de eliminar os modelos, você pode usar qualquer uma das opções disponíveis.
/**
* Elimina un usuario
* @param type SlimHttpRequest $request - la solicitud http
* @param type SlimHttpResponse $response - la respuesta http
* @param type array $args - argumentos para la función
*/
public function elimina ( $ request , $ response , $ args )
{
$ usuario = Usuario-> find ( $ args [ ' id ' ]);
$ validaID = [v:: intVal ()-> validate ( $ id )];
if ( $ usuario && $ validaID ){
// si existe el usuario y la validación es correcta, lo elimina
$ usuario -> delete ();
}
/*
regresa una respuesta con la uri y redirecciona a la lista de usuarios,
se haya o no eliminado el usuario
*/
$ uri = $ request -> getUri ()-> withQuery ( '' )-> withPath ( $ this -> router -> pathFor ( ' listaUsuarios ' ));
return $ response -> withRedirect (( string ) $ uri );
}
A implementação de rotas finas foi construída a partir do Fastoute 5 e fornece métodos para poder trabalhar com os métodos HTTP mais comumente usados, ou seja, obter , postar , colocar , excluir , patch , opções que podem ser tratadas uma a uma ou uma maneira de gerar com o método any() slim. Além disso, é possível lidar com vários métodos em uma única rota usando a função map() . Em nosso aplicativo, as rotas são encontradas no arquivo src/routes.php que contém a rota que carrega a visualização da página de esqueleto inicial, não precisamos dele, e você pode remover ou comentar para guiá -lo ao criar as outras rotas. Usaremos os métodos GET para carregar visualizações e ver usuários, postar para criar usuários, patches para atualizar um usuário e delegar para excluir.
As rotas que lidam com apenas http get solicitações usam o método get() de slim, que recebe como argumentos um padrão de rota (com marcadores de posição opcional) e uma função de retorno de chamada que pode vir de um controlador ou declarar na mesma rota.
$ app -> get ( ' / ' , function ( $ request , $ response , $ args ){
return $ this -> view -> render ( $ response , " index.twig " );
})-> setName ( ' inicio ' ); O que esta rota está fazendo é, para o padrão "/" (que seria o padrão inicial do servidor) para chamar uma função que retorna em resposta a exibição definida no index.twig modelo.
// ruta para cargar la vista de todos los usuarios registrados
$ app -> get ( ' /listaUsuarios ' , function ( $ request , $ response , $ args ){
return $ this -> view -> render ( $ response , ' listaUsuarios.twig ' );
})-> setName ( ' listaUsuarios ' );
/*
ruta para cargar la vista de un usuario en especifico definido por su id
empleando la función buscaUsuarioID() de la clase ControladorUsuario,
previamente agregada al CID de la aplicación
*/
$ app -> get ( ' /listaUsuarios/{id} ' , ' ControladorUsuario:buscaUsuarioID ' )-> setName ( ' usuario.ver ' );
// ruta para cargar el formulario para crear usuario
$ app -> get ( ' /nuevo ' , function ( $ request , $ response , $ args ){
return $ this -> view -> render ( $ response , ' formulario_crea.twig ' );
})-> setName ( ' usuario.crear ' );
// ruta para cargar el formulario para actualizar usuario
$ app -> get ( ' /listaUsuarios/{id}/actualiza ' , function ( $ request , $ response , $ args ){
return $ this -> view -> render ( $ response , ' formulario_actualiza.twig ' );
})-> setName ( ' usuario.editar ' );
Como nos aplicativos GET , o Slim possui uma função post() para lidar com solicitações de postagem . Essa função também recebe como parâmetros o padrão da rota (com marcadores de posição opcional) e uma função de retorno de chamada.
// ruta para crear un nuevo usuario
$ app -> post ( " /nuevo " , " ControladorUsuario:crea " ); Pode -se notar que essa rota não usa a função setName() porque já existe uma rota com o mesmo padrão ("/novo"), mas usando métodos diferentes, ambos podem compartilhar o mesmo nome.
Para Patch, o que é mencionado acima também é cumprido para obter e postar . Então, para atualizar, teríamos um pouco desse estilo:
// ruta para actualizar un usuario
$ app -> patch ( ' listaUsuarios/{id} ' , ' ControladorUsuario:actualiza ' )-> setName ( ' usuario.actualizar ' ); // ruta para eliminar un usuario
$ app -> delete ( ' listaUsuario/{id} ' , ' ControladorUsuario:elimina ' )-> setName ( ' usuario.eliminar ' );Já sabemos que o Slim não tem uma ferramenta para gerar os modelos de suas opiniões e, de fato, as visões são apenas parte do corpo das respostas HTTP do PSR-7 que implementos finos, de modo que eles necessariamente dependem das rotas. No entanto, eles podem ser fornecidos por componentes de componentes e eles mesmos fornecem as implementações de dois desses componentes, Twig e PHP-View . Pessoalmente, prefiro o galho, pois me causou menos problemas e, em geral, ele tem uma estrutura mais clara porque sua sintaxe é baseada nos modelos Jinja e Django. É claro que, como tudo em Slim, o uso de componentes é uma questão de sabor e outras ferramentas podem ser tratadas para gerar nossas opiniões.
Primeiro, e como no restante das unidades, adicionaremos o Twig usando o Composer .
$ composer require slim/twig-view
Nota : Se você deseja usar o PHP-View em vez de Twig , ele apenas substitui slim/twig-view por slim/php-view
Após a instalação do galho , ele também deve ser adicionado ao CID do aplicativo, para que o Slim o registre como um dos serviços e possa usá -lo.
$ container [ ' view ' ] = function ( $ c ) {
$ settings = $ c -> get ( ' settings ' )[ ' renderer ' ]; //nos indica el directorio donde están las plantillas
$ view = new Slim Views Twig ( $ settings [ ' template_path ' ], [
' cache ' => false ,]); // puede ser false o el directorio donde se guardará la cache
// instancia y añade la extensión especifica de slim
$ basePath = rtrim ( str_ireplace ( ' index.php ' , '' , $ c [ ' request ' ]-> getUri ()-> getBasePath ()), ' / ' );
$ view -> addExtension ( new Slim Views TwigExtension ( $ c [ ' router ' ], $ basePath ));
return $ view ;
};Em uma estrutura básica de galhos , encontraremos 3 tipos de delimitores:
Como o design do galho é baseado em modelos, podemos criar um layout.twig Modelo e herdar o restante dos modelos.
<! DOCTYPE html>
<html>
<head>
<title> CRUD SLIM </title>
<meta charset="utf- 8 ">
<meta name="viewport" content="width=device-width, initial-scale= 1 ">
{% block stylesheets %}
{ # Aquí incluimos los archivos CSS o CDN de CSS que usemos #}
<link href="url de cdn" type="text/css" rel="stylesheet" />
{ # la función base_url() le indica a twig que busque desde el directorio raíz de proyecto #}
<link href="{{ base_url() }}/directorio/de/css" type="text/css" rel="stylesheet" />
{% endblock %}
{%block scripts }
{ # Aqui incluimos los .js y otros scripts
<script src="{{ base_url() }}/directorio/de/scripts"></script>
{% endblock %}
</head>
<body>
{% block content %}{% endblock %}
</div>
</body>
</html> Podemos ter os modelos herdados do layout.twig em outro diretório, por exemplo templates/crud para manter a hierarquia organizada entre eles.
Se lembrarmos das rotas, a visão que é carregada ao iniciar o aplicativo é index.twig que teria uma estrutura como a seguinte:
{% extends ' layout.twig ' %}
{% block content %}
{ # la función path_for('') llama la ruta con el nombre que recibe como parametro #}
<a href="{{ path_for ( ' listaUsuarios ' ) }} " >Lista los usuarios registrados</a>
<a href= " {{ path_for ( ' usuario.crear ' ) }} " >Agrega un nuevo usuario</a>
{% endblock %}
Forma formulario_crea.twig
{% extends ' layout.twig ' %}
{% block content %}
{ # manda los datos del formulario a la ruta 'usuario.crear' con un método post #}
<form action="{{ path_for ( ' usuario.crear ' ) }} " method= " post" autocomplete="off">
<label for="nombre">Nombre
<input type="text" name="nombre" id="nombre" placeholder="Escribe tu nombre">
</label>
<label for="correo">Correo
<input type="email" name="correo" id="correo" placeholder="Escribe tu correo">
</label>
<label for="clave_acceso">Contraseña
<input type="password" name="clave_acceso" id="clave_acceso" placeholder="Escribe tu contraseña">
<button type="submit">Agregar</button>
{% endblock %} Forma de formulario_actualiza.twig
{% extends ' layout.twig ' %}
{% block content %}
{ # manda los datos del formulario a la ruta 'usuario.actualizar' con un método patch #}
<form action="{{ path_for ( ' usuario.actualizar ' ) }} " method= " patch" autocomplete="off">
<label for="nombre">Nombre
<input type="text" name="nombre" id="nombre" placeholder="Escribe tu nombre">
</label>
<label for="correo">Correo
<input type="email" name="correo" id="correo" placeholder="Escribe tu correo">
</label>
<label for="clave_acceso">Contraseña
<input type="password" name="clave_acceso" id="clave_acceso" placeholder="Escribe tu contraseña">
<button type="submit">Actualiza</button>
{% endblock %} listaUsuario.twig Estrutura
{% extends ' layout.twig ' %}
{% block content %}
<table>
<thead>
<tr>
<th>Nombre</th>
<th>Correo</th>
</tr>
</thead>
<tbody>
{ # itera la tabla usuarios del modelo #}
{% for usuario in usuarios %}
<tr>
<td>{{ usuario.nombre }}</td>
<td>{{ usuario.correo }}</td>
<td><a href="{{ path_for ( ' usuario.ver ' ) }} " >ver</a></td>
<td><a href= " {{ path_for ( ' usuario.eliminar ' ) }} " >eliminar</a><td>
</tr>
{% endfor %}
</tbody>
</table>
{% endblock %} Estrutura usuario.twig
{% extends ' layout.twig ' %}
{% block content %}
<h1>{{ usuario.nombre }}</h1>
<h2>{{ usuario.correo }}</h2>
<img src="http: //i.imgur.com/Y9IVuHg.jpg"/>
{% endblock %}Lembre -se de que a premissa dessa estrutura é usar apenas o que você considera necessário e não mais do que isso; A escala do seu projeto é definida por você e não pela estrutura.
1: mariadbcom. (2016). Mariadbcom. Recuperado em 25 de setembro de 2016, em https://mariadb.com/blog/why-shand-you-migrate-mysql-mariadb.
2: Como instalar o compositor programaticamente?#. (ND). Recuperado em 25 de setembro de 2016, em https://getcomposer.org/doc/faqs/how-tonstall-composer-programaticaticamente.md.
3: Eloquente: Introdução - Laravel - a estrutura PHP para artesãos da web. (ND). Recuperado em 29 de setembro de 2016, de https://lavel.com/docs/5.1/eloquent
4: Validação efetiva com respeito. Recuperado em 30 de setembro de 2016, em https://websec.io/2013/04/01/effective-validation-with-respect.html
5: N. (2016). FastTroute. Recuperado em 12 de outubro de 2016, de https://github.com/nikic/fastoute
Codecourse (2016, 13 de abril). Autenticação com Slim 3 Recuperado em https://www.youtube.com/playlist?ist=plfdthywgc_yy90xrdq6mrww042aec
Rob Allen's DevNotes. (2016, 28 de julho). Recuperado em 08 de novembro de 2016, em https://akrabat.com/category/slim-framework/
