Slim CRUD
1.0.0
Die Art und Weise, wie SLIM von seinen Entwicklern empfohlen wird, ist der PHP -Komponist.
Wenn Sie eine Verteilung wie Arch Linux oder basierend darauf verwenden, befindet sich Komponist in den offiziellen Repositories, sodass Sie sie mit Pacman installieren können.
# pacman -S composer
Falls nicht die Installation von Komponisten in der Konsole den folgenden Befehl schreibt:
$ curl -sS https://getcomposer.org/installer | sudo php -- --install-dir=/usr/local/bin --filename=composer
Oder wenn Sie es vorziehen, können Sie das folgende Skript 2 verwenden:
#! /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
Gespeichert als install-composer.sh , um es im Terminal mit dem Befehl auszuführen
$ sh install-composer.sh
Hinweis : Durch diese Methode können wir den Komponisten auf dem neuesten Stand halten, aber Sie müssen die Datei composer.phar in den Ordner /usr/local/bin/ mit dem Befehl verschieben
# mv composer.phar /usr/local/bin/composer
Auf diese Weise können Sie Komponisten nur composer in der Konsole anstelle von php <Directorio>composer.phar ausführen.
Wenn Sie Windows-Benutzer sind, müssen Sie die Composer-Setup.*.exe des offiziellen Komponisten-Repositorys in Github, der unter https://github.com/composer/windows-setup/releass/ ist und den Anweisungen befolgen, die Sie Ihnen den Installateur geben.
Wir können ein Projekt von Grund auf neu erstellen oder das von Slim bereitgestellte Skelett verwenden, das uns eine einfache Konfiguration gibt, um die Anwendung zu starten. Sie müssen nur die folgenden in der Konsole schreiben:
$ composer create-proyect slim/slim-skeleton crud-slim
Dadurch wird ein neues crud-slim -Verzeichnis mit den erforderlichen Dateien erstellt, um die Anwendung zu schreiben.
Verzeichnisstruktur
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/...
HINWEIS: Der Verwaltungsrat vendor/ enthält viele stellvertretende Direktor, es wird jedoch nicht empfohlen, eine der hier enthaltenen Dateien zu bearbeiten, da alle Einheiten, die wir in der Anwendung verwenden, und diese Änderungen auf den Betrieb davon beeinflussen würden.
Wenn wir php -S localhost:8080 -t public public/index.php im Verzeichnis unserer Anwendung ausführen und unseren Browser in der localhost:8080 Die folgende Ansicht wird angezeigt
Wir erstellen eine Datenbank mit dem Namen slim
$ mysql -u[nombre-de-usuario] -p
> CREATE DATABASE slim COLLATE = 'utf8_unicode_ci';
> u slim
Wir fügen die usuarios hinzu.
> 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 ` ));Wir erstellen die Datenbank, die wir für das CRUD verwenden werden:
Wir erstellen die Benutzertabelle:
Nachdem wir die Datenbank haben, müssen wir sie der schlanken Konfiguration hinzufügen. Zu diesem Zweck öffnen wir die Datei settings.php im src -Verzeichnis und enthält Folgendes:
<?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 ,
],
],
];
Wir fügen die Konfiguration unserer Datenbank nach dem Feld logger hinzu
//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 ' => '' ,
],
Um die Klassen, die wir später erstellen, automatisch zu laden, müssen wir in der composer.json hinzufügen. Jon A Autoload -Mapping mit der PHP PSR-4- Konvention.
"autoload" : {
"psr-4" : {
"App\" : "src/"
}
} Jetzt müssen Sie das Anwendungsmodell erstellen. Obwohl SLIM nicht dem MVC-Designmuster (Modell-Vista-Controller) auf konventionelle Weise folgt, sollten wir für jede Komponente ein exklusives Verzeichnis haben. Daher erstellen wir ein Verzeichnis für das Modell innerhalb von src/ mit unserem Datei-Explorer oder mit dem Befehl mkdir modelos aus dem src -Verzeichnis.
Wie wir wissen, hat Slim kein Tool für die Standard-Objektverlust-Zuordnung. Es ermöglicht uns jedoch, einen anderen in PHP geschriebenen Framework hinzuzufügen. In diesem Fall werden wir eloquent 3 von Laravel verwenden.
Um unserem CRUD eloquent hinzuzufügen, müssen wir den Komponisten zuerst bitten, es den Abhängigkeiten unserer Bewerbung hinzuzufügen.
$ composer require illuminate/database " ~5.1 " Dann fügen wir dem Injektionsbehälter der Abhängigkeiten (im Folgenden CID ) der Anwendung eloquent hinzu. Wir öffnen die Datei dependencies.php , die sich im src -Verzeichnis befindet, und wir fügen sie hinzu
$ container [ ' db ' ] = function ( $ container ) {
$ capsule = new Illuminate Database Capsule Manager ;
$ capsule -> addConnection ( $ container [ ' settings ' ][ ' db ' ]);
return $ capsule ;
}; Um eloquent in der Anwendung zu initialisieren, muss sie vor app->run(); auch zu der public/index.php hinzugefügt werden.
$ capsule = $ app -> getContainer ()-> get ( ' capsule ' ); // toma el elemento capsule dentro del contenedor de la app
$ capsule -> bootEloquent (); // inicializa EloquentWir erstellen die Modelless -Klasse innerhalb des Verwaltungsrates.
<?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 ' ,
];
} Wir werden auch eine controladores innerhalb von src für Anwendungsfahrer erstellen. Sobald das Verzeichnis erstellt wurde, werden wir darin eine nützliche Controller -Klasse erstellen, die den Betrieb der Anwendung übernimmt. Darüber hinaus installieren wir, wie unsere Controller validieren, das Validation 4 Validation Tool über Komponist .
$ 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 --*/
}Sie müssen den Benutzer auch zur Anwendung der Anwendung hinzufügen, damit er ihn verwenden kann.
$ container [ ' ControladorUsuario ' ] = function ( $ container ){
return new App Controladores ControladorUsuario ( $ container );
}; Denken Sie daran, dass wir in modelUSuario einen füllbaren Teil für die Tabelle definieren. Dies liegt daran, id in der Datenbank als erhöhtes Auto -Attribut definiert sind, dann müssen wir nur die anderen 3 Felder in die Datenbank eingeben, und wir werden es mit dieser Funktion tun:
/**
* 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
}
}
} Hier werden zwei Funktionen veranschaulicht, eine, die allen registrierten Benutzern angezeigt wird, und ein anderer, bei dem ein bestimmter Benutzer angezeigt wird. Die Struktur der lista.twig und usuario.twig wird im Abschnitt "Ansicht" genauer erläutert.
/**
* 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 );
}
} Beispiel für eine Funktion zum Aktualisieren eines Benutzers.
/**
* 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 bietet drei Möglichkeiten, Elemente aus einer Tabelle zu entfernen: Die erste besteht darin, eine Instanz des Modells zu beseitigen, aus dem sein Primärschlüssel nicht bekannt ist. Sie verwendet die delete , aber der Nachteil besteht darin, dass Sie die gesamte Instanz wiederherstellen müssen, bevor Sie delete aufrufen. Die zweite ist unter der Annahme, dass der Primärschlüssel des Modells bekannt ist, die destroy , die das Modell beseitigt, ohne die vollständige Instanz wiederherzustellen. Die dritte Option ist durch Konsultationen, beispielsweise $eliminados = Usuario::where('nombre','like','C%')->delete(); Ich würde alle Benutzer eliminieren, deren Name mit "C" beginnt. Darüber hinaus hat eloquent weiche Deeting , dh das Modell wird nicht aus der Datenbank gelöscht, aber ein deleted_at -Attribut wird hinzugefügt, und wie von Laravel -Entwicklern empfohlen, sollte eine Spalte in die Tabelle hinzugefügt werden, um diese Attribute zu enthalten. Um die Soft Deosting -Methode in der Anwendung zu aktivieren, müssen Sie die IlluminateDatabaseEloquentSoftDeletes in den App -Modellen hinzufügen. Das folgende Beispiel verwendet delete , um Validierungen vorzunehmen und mehr Robustheit zu verleihen, bevor die Modelle eliminiert werden. Sie können die verfügbaren Optionen nutzen.
/**
* 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 );
}
Die Implementierung schlanker Routen wurde aus Fastroute 5 erstellt und bietet Methoden , um mit den am häufigsten verwendeten any() -Methoden arbeiten zu können. Darüber hinaus ist es möglich, mehrere Methoden auf einer einzelnen Route mithilfe der Funktion map() zu verarbeiten. In unserer Anwendung finden Sie die Routen in der Datei src/routes.php , die die Route enthält, die die Ansicht der anfänglichen Skelettseite lädt. Wir benötigen sie nicht, dann können Sie Sie entfernen oder kommentieren, um Sie beim Erstellen der anderen Routen zu führen. Wir werden die GET -Methoden verwenden , um Ansichten zu laden und Benutzer anzusehen, Benutzer zu erstellen, zu patchigen , um einen Benutzer zu aktualisieren, und zum Löschen von Delegierungen zu aktualisieren.
Die Routen, die nur HTTP -Anforderungen verarbeiten, verwenden die get() -Slim -Methode, die als Argumente ein Routenmuster (mit optionalen Positionsmarkierungen) und eine Rückruffunktion empfängt, die von einem Controller stammen oder auf derselben Route deklariert werden kann.
$ app -> get ( ' / ' , function ( $ request , $ response , $ args ){
return $ this -> view -> render ( $ response , " index.twig " );
})-> setName ( ' inicio ' ); Diese Route ist für das Muster "/" (das das ursprüngliche Muster des Servers wäre) eine Funktion aufzurufen, die als Antwort auf die im index.twig definierte Ansicht zurückgibt.
// 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 ' );
Wie bei GET -Anwendungen hat SLIM eine post() -Funktion, um Postanforderungen zu verarbeiten. Diese Funktion empfängt auch als Parameter das Muster der Route (mit optionalen Positionsmarkierungen) und eine Rückruffunktion.
// ruta para crear un nuevo usuario
$ app -> post ( " /nuevo " , " ControladorUsuario:crea " ); Es kann beachtet werden, dass diese Route die Funktion setName() nicht verwendet, da bereits eine Route mit demselben Muster ("/neu ") vorhanden ist, aber die Verwendung verschiedener Methoden können denselben Namen teilen.
Für Patch wird auch das, was oben erwähnt wird, auch für Get and Post erfüllt. Um zu aktualisieren, hätten wir einen Teil dieses Stils:
// 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 ' );Wir wissen bereits, dass Slim kein Werkzeug hat, um die Vorlagen ihrer Ansichten zu erzeugen, und in der Tat sind die Ansichten nur ein Teil des Körpers der PSR-7-HTTP-Antworten, die schlanke implementiert, so dass sie notwendigerweise von den Routen abhängen. Sie können jedoch von Komponentenkomponentenkomponenten bereitgestellt werden und bieten selbst die Implementierungen von zwei dieser Komponenten, Twig und PHP-View . Ich persönlich bevorzuge Twig, da es mir weniger Probleme verursachte und im Allgemeinen eine klarere Struktur hat, da seine Syntax auf Jinja- und Django -Vorlagen basiert. Natürlich ist wie alles in Slim die Verwendung von Komponenten eine Frage des Geschmacks und andere Werkzeuge können behandelt werden, um unsere Ansichten zu erzeugen.
Erstens und wie bei den übrigen Einheiten werden wir den Zweig mit Komponisten hinzufügen.
$ composer require slim/twig-view
Hinweis : Wenn Sie PHP-View anstelle von Twig verwenden möchten, ersetzt es nur slim/twig-view durch slim/php-view
Nach dem Installieren von Twig muss es auch zur CID der Anwendung hinzugefügt werden, damit Slim es als eines der Dienste registriert und sie nutzen kann.
$ 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 ;
};In einer grundlegenden Zweigstruktur finden wir 3 Arten von Begrenzern:
Da das Twig -Design auf Vorlagen basiert, können wir ein layout.twig erstellen. Twig -Basisvorlage und den Rest der Vorlagen erben.
<! 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> Wir können die Vorlagen von layout.twig in einem anderen Verzeichnis erben lassen, z. B. templates/crud um die Hierarchie zwischen ihnen zu organisieren.
Wenn wir uns an die Routen erinnern, ist die Ansicht, die beim Starten der Anwendung lädt, index.twig , die eine Struktur wie die folgenden hat:
{% 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 %}
Form 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 %} Form von 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 Struktur
{% 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 %} usuario.twig
{% extends ' layout.twig ' %}
{% block content %}
<h1>{{ usuario.nombre }}</h1>
<h2>{{ usuario.correo }}</h2>
<img src="http: //i.imgur.com/Y9IVuHg.jpg"/>
{% endblock %}Denken Sie daran, dass die Prämisse dieses Rahmens darin besteht, nur das zu verwenden, was Sie für notwendig halten, und nicht mehr als das. Die Skala Ihres Projekts wird von sich selbst und nicht durch den Rahmen definiert.
1: Mariadbcom. (2016). Mariadbcom. Abgerufen am 25. September 2016 von https://mariadb.com/blog/why-hould-you-migrate-mysql-mariadb.
2: Wie installiere ich Composer programmmatisch?#. (ND). Abgerufen am 25. September 2016 von https://getcomposer.org/doc/faqs/how-t-in-install-composer-programatic.md.
3: eloquent: Erste Schritte - Laravel - Das PHP -Framework für Webartisans. (ND). Abgerufen am 29. September 2016 von https://lavel.com/docs/5.1/eloquent
4: Effektive Validierung mit Respekt. Abgerufene September 2016 von https://websec.io/2013/04/01/effective-validation-with-resspect.html
5: N. (2016). FastTroute. Abgerufen am 12. Oktober 2016 von https://github.com/nikic/fastroute
Codecourse (2016, 13. April). Authentifizierung mit Slim 3 abgerufen von https://www.youtube.com/playlist?ist=plfdthywgc_yy90xrdq6mrww042aec
Rob Allens Devnotes. (2016, 28. Juli). Abgerufen am 08. November 2016 von https://akrabat.com/category/slim-framework/
