Slim CRUD
1.0.0
La façon d'installer Slim recommandée par ses développeurs est via PHP Composer.
Si vous utilisez une distribution comme Arch Linux ou sur la base de cela, le compositeur est dans les référentiels officiels, afin que vous puissiez l'installer avec Pacman.
# pacman -S composer
Dans le cas, pour installer le compositeur écrit dans Console la commande suivante:
$ curl -sS https://getcomposer.org/installer | sudo php -- --install-dir=/usr/local/bin --filename=composer
Ou si vous préférez, vous pouvez utiliser le script suivant 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
Enregistré en tant install-composer.sh pour l'exécuter dans le terminal avec la commande
$ sh install-composer.sh
Remarque : Grâce à cette méthode, nous pouvons tenir le compositeur à jour, mais vous devez déplacer le fichier composer.phar vers le dossier /usr/local/bin/ avec la commande
# mv composer.phar /usr/local/bin/composer
De cette manière, vous pouvez exécuter composer composé uniquement composer dans Console au lieu de php <Directorio>composer.phar .
Si vous êtes l'utilisateur de Windows, vous devez télécharger le Composer-Setup.*.exe du référentiel de compositeurs officiels dans GitHub, qui est à https://github.com/composer/windows-setup/releases/ et suivez les instructions que vous vous donnez.
Nous pouvons créer un projet à partir de zéro ou utiliser le squelette fourni par Slim, ce qui nous donne une configuration simple pour démarrer l'application, il vous suffit d'écrire ce qui suit dans Console:
$ composer create-proyect slim/slim-skeleton crud-slim
Cela créera un nouveau répertoire crud-slim avec les fichiers nécessaires pour commencer à écrire l'application.
Structure de répertoire
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/...
Remarque: Le conseil vendor/ contient de nombreux administrateurs adjoints, mais il n'est pas recommandé de modifier aucun des fichiers contenus ici, car c'est là que toutes les unités que nous utiliserons dans l'application et les modifieraient affecteraient son fonctionnement.
Si nous exécutons php -S localhost:8080 -t public public/index.php dans le répertoire de notre application et ouvrez notre navigateur dans l' localhost:8080 La vue suivante apparaîtra
Nous créons une base de données avec le nom slim
$ mysql -u[nombre-de-usuario] -p
> CREATE DATABASE slim COLLATE = 'utf8_unicode_ci';
> u slim
Nous ajoutons le tableau 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 ` ));Nous créons la base de données que nous utiliserons pour le crud:
Nous créons la table d'utilisateurs:
Maintenant que nous avons la base de données, nous devons l'ajouter à la configuration mince. Pour cela, nous ouvrons le fichier settings.php situé dans le répertoire src et qui contient ce qui suit:
<?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 ,
],
],
];
Nous ajoutons après le champ logger la configuration de notre base de données
//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 ' => '' ,
],
De plus, pour charger automatiquement les classes que nous créerons plus tard, nous devons ajouter le fichier composer.json . Jon A Mapping Autoload avec la convention PHP PSR-4 .
"autoload" : {
"psr-4" : {
"App\" : "src/"
}
} Vous devez maintenant créer le modèle d'application. Bien que Slim ne suit pas le modèle de conception MVC (modèle-Vista-contrôleur) de manière conventionnelle, nous devrions avoir un répertoire exclusif pour chaque composant, nous allons donc créer un répertoire pour le modèle dans src/ avec notre fichier Explorer ou avec la commande mkdir modelos à partir du répertoire src .
Comme nous le savons, Slim n'a pas d'outil pour le mappage par défaut d'objet-objet. Cependant, cela nous permet d'ajouter un autre cadre écrit en PHP; Dans ce cas, nous utiliserons Eloquent 3 de Laravel.
Pour ajouter éloquent à notre crud, nous devons d'abord demander au compositeur de l'ajouter aux dépendances de notre application.
$ composer require illuminate/database " ~5.1 " Ensuite, nous ajoutons éloquents au conteneur d'injection des dépendances (ci-après CID ) de l'application. Nous ouvrons le fichier de dependencies.php qui se trouve dans le répertoire src et nous l'ajoutons
$ container [ ' db ' ] = function ( $ container ) {
$ capsule = new Illuminate Database Capsule Manager ;
$ capsule -> addConnection ( $ container [ ' settings ' ][ ' db ' ]);
return $ capsule ;
}; Pour initialiser éloquent dans l'application, il doit également être ajouté au public/index.php avant app->run();
$ capsule = $ app -> getContainer ()-> get ( ' capsule ' ); // toma el elemento capsule dentro del contenedor de la app
$ capsule -> bootEloquent (); // inicializa EloquentNous créons la classe sans modélisation au sein du conseil d'administration.
<?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 ' ,
];
} Nous créerons également des controladores au sein de src pour les pilotes d'application. Une fois le répertoire créé, nous créerons en lui une classe de contrôleur utile qui gérera le fonctionnement de l'application. De plus, comme nos contrôleurs valideront, nous installons l'outil de validation de validation 4 via 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 --*/
}Vous devez également ajouter l' utilisateur à l' application de l'application afin qu'il puisse l'utiliser.
$ container [ ' ControladorUsuario ' ] = function ( $ container ){
return new App Controladores ControladorUsuario ( $ container );
}; Rappelons que dans ModeluSuario, nous définissons une partie remplissable pour le tableau, c'est parce que le id défini dans la base de données comme un attribut automatique accru, alors nous avons seulement besoin de saisir les 3 autres champs dans la base de données et nous le ferons avec cette fonction:
/**
* 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
}
}
} Ici, deux fonctions sont illustrées, une pour afficher tous les utilisateurs enregistrés et un autre où un utilisateur spécifique affiche. La structure de la lista.twig des modèles.twig et usuario.twig mentionnées seront expliquées plus en détail dans la section View.
/**
* 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 );
}
} Exemple d'une fonction pour mettre à jour un utilisateur.
/**
* 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 );
}
}
} Eloquent a trois façons d'éliminer les éléments d'un tableau: le premier consiste à éliminer une instance du modèle à partir de laquelle sa clé principale n'est pas connue, elle utilise la fonction delete mais son inconvénient est que vous devez récupérer toute l'instance avant d'appeler delete ; La seconde est que, en supposant que la clé principale du modèle est connu, appelle la fonction destroy qui élimine le modèle sans avoir à récupérer l'instance complète; La troisième option est par consultations, par exemple $eliminados = Usuario::where('nombre','like','C%')->delete(); J'éliminerais tous les utilisateurs dont le nom commence par "C". De plus, Eloquent a un déetting doux , c'est-à-dire que le modèle n'est pas supprimé de la base de données, mais un attribut deleted_at est ajouté et, comme recommandé par les développeurs de Laravel, une colonne doit être ajoutée au tableau pour contenir lesdits attributs. Pour activer la méthode de déosting doux dans l'application, vous devez ajouter la IlluminateDatabaseEloquentSoftDeletes dans les modèles d'application. L'exemple suivant utilise delete pour effectuer des validations et donner plus de robustesse avant d'éliminer les modèles, vous êtes libre d'utiliser l'une des options disponibles.
/**
* 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 );
}
L' implémentation de routes Slim a été construite à partir de FastRoute 5 et fournit des méthodes pour pouvoir travailler avec les méthodes HTTP les plus couramment utilisées, c'est-à-dire, publier , publier , supprimer , patcher , options qui peuvent être gérées une par un ou toutes de manière à générer avec la méthode any() mince. De plus, il est possible de gérer plusieurs méthodes sur un seul itinéraire à l'aide de la fonction map() . Dans notre application, les itinéraires se trouvent dans le fichier src/routes.php qui contient l'itinéraire qui charge la vue de la page de squelette initiale, nous n'en avons pas besoin, puis vous pouvez supprimer ou commenter pour vous guider lors de la création des autres itinéraires. Nous utiliserons les méthodes GET pour charger des vues et voir les utilisateurs, publier pour créer des utilisateurs, patcher pour mettre à jour un utilisateur et déléguer à supprimer.
Les itinéraires qui ne gèrent que les demandes de GET HTTP utilisent la méthode get() de SLIM, qui reçoit comme arguments un modèle d'itinéraire (avec des marqueurs de position facultative) et une fonction de rappel qui peut provenir d'un contrôleur ou déclarer sur la même route.
$ app -> get ( ' / ' , function ( $ request , $ response , $ args ){
return $ this -> view -> render ( $ response , " index.twig " );
})-> setName ( ' inicio ' ); Ce que cette route fait est, pour le modèle "/" (qui serait le modèle initial du serveur) d'appeler une fonction qui revient en réponse la vue définie dans l' index.twig modèle.twig déjà cette route attribue le nom "à la maison" afin que les vues puissent les interpréter plus facilement.
// 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 ' );
Comme pour les applications Get , Slim a une fonction post() pour gérer les demandes de poste . Cette fonction reçoit également en tant que paramètres le modèle de l'itinéraire (avec des marqueurs de position facultatif) et une fonction de rappel.
// ruta para crear un nuevo usuario
$ app -> post ( " /nuevo " , " ControladorUsuario:crea " ); On peut noter que cet itinéraire n'utilise pas la fonction setName() car il existe déjà un itinéraire avec le même modèle ("/ new") mais en utilisant différentes méthodes, les deux peuvent partager le même nom.
Pour le patch, ce qui est mentionné ci-dessus est également rempli pour GET et POST . Donc, pour mettre à jour, nous aurions une partie de ce style:
// 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 ' );Nous savons déjà que Slim n'a pas d'outil pour générer les modèles de leurs vues et, en fait, les vues ne sont qu'une partie du corps des réponses HTTP PSR-7 que Slim s'implémente, de sorte qu'elles dépendent nécessairement des itinéraires. Cependant, ils peuvent être fournis par des composants de composants et ils fournissent eux-mêmes les implémentations de deux de ces composants, Twig et PHP-View . Personnellement, je préfère les brindilles car cela m'a causé moins de problèmes et en général, il a une structure plus claire car sa syntaxe est basée sur des modèles Jinja et Django. Bien sûr, comme tout dans Slim, l'utilisation des composants est une question de goût et d'autres outils peuvent être manipulés pour générer nos vues.
Tout d'abord, et comme avec le reste des unités, nous ajouterons des brindilles à l'aide du compositeur .
$ composer require slim/twig-view
Remarque : Si vous souhaitez utiliser PHP-View au lieu de Twig , il remplace uniquement slim/twig-view par slim/php-view
Après avoir installé des brindilles , il doit également être ajouté au CID de l'application afin que Slim l'informe comme l'un des services et puisse l'utiliser.
$ 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 ;
};Dans une structure de brindilles de base, nous trouverons 3 types de délimiteurs:
Comme la conception des brindilles est basée sur des modèles, nous pouvons créer un modèle de base de layout.twig et hériter du reste des modèles.
<! 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> Nous pouvons avoir les modèles hérités de layout.twig dans un autre répertoire, par exemple templates/crud pour maintenir la hiérarchie organisée entre eux.
Si nous nous souvenons des itinéraires, la vue qui se charge lors du démarrage de l'application est index.twig qui aurait une structure comme la suivante:
{% 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 %}
Forme 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 %} Forme 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 Structure
{% 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 %} Structure usuario.twig
{% extends ' layout.twig ' %}
{% block content %}
<h1>{{ usuario.nombre }}</h1>
<h2>{{ usuario.correo }}</h2>
<img src="http: //i.imgur.com/Y9IVuHg.jpg"/>
{% endblock %}N'oubliez pas que la prémisse de ce cadre est d'utiliser uniquement ce que vous considérez nécessaire et pas plus que cela; L'échelle de votre projet est définie par vous-même et non par le cadre.
1: Mariadbcom. (2016). Mariadbcom. Récupéré le 25 septembre 2016 de https://mariadb.com/blog/why-should-you-migrate-mysql-mariadb.
2: Comment installer le compositeur programmatiquement? #. (Nd). Extrait le 25 septembre 2016 de https://getcomposer.org/doc/faqs/how-to-install-composer-programmatemated.md.
3: Eloquent: Démarrage - Laravel - Le cadre PHP pour les artisans Web. (Nd). Extrait le 29 septembre 2016 de https://lavel.com/docs/5.1/elognent
4: validation efficace par rapport à. Extrait le 30 septembre 2016 de https://webec.io/2013/04/01/Effective-validation-with-respect.html
5: N. (2016). FastTroute. Récupéré le 12 octobre 2016 de https://github.com/nikic/fastRoute
Code de code (2016, 13 avril). Authentification avec Slim 3 récupéré de https://www.youtube.com/playlist?ist=plfdthywgc_yy90xrdq6mrww042aec
Devnotes de Rob Allen. (2016, 28 juillet). Extrait le 08 novembre 2016 de https://akrabat.com/category/slim-framework/
