Seamos realistas: todos tenemos grandes ideas para una aplicación web. Ya sea que los escriba en un papel o los recuerde utilizando su memoria eidética, llega un momento en el que desea probar si su idea es realmente viable o no..

En este tutorial, usaremos un micro marco, un lenguaje de plantillas y un ORM para desarrollar rápidamente un prototipo de aplicación.

Paso 1: Introducción y configuración

Todos hemos tenido ese sentimiento. Ya sabes, en el que sabes que tienes una gran idea de aplicación web, solo que no tienes tiempo para preparar un prototipo rápido y probar que la idea realmente funcionará. Usando un micro marco, un lenguaje de plantillas y un ORM, podría tenerlo en funcionamiento en minutos.

Para este tutorial, usaremos el excelente micro marco Slim, el lenguaje de plantillas Twig y el ligero ORM Paris e Idiorm. Nuestra aplicación de muestra será un blog. Probablemente ya hayas creado un blog, pero estamos aquí para aprender sobre los micro marcos, y un blog encaja perfectamente.!

Lo primero que querrá hacer es tomar estos paquetes de sus respectivos sitios web:

• Slim 1.5.02 (lanzamiento estable)
• Slim Extras
• Ramita 1.1
• Paris y idiorm

Ahora que tiene todos los paquetes descargados en su computadora, es hora de configurar la estructura de su directorio. Pondremos los archivos en la carpeta raíz de nuestro sitio, por lo que su carpeta de proyecto debería tener el siguiente aspecto:

"No olvide incluir el archivo .htaccess que viene con Slim".

Ahora que hemos estructurado nuestro proyecto, siga adelante y elimine los contenidos de Slim index.php archivo - vamos a escribir nuestro propio un poco más adelante. También puede desechar todo menos el TwigView.php archivo de clase en el paquete de extras Slim.

Paso 2: Bootstrapping

Nuestro index.php El archivo actuará como un bootstrap, que hará que Slim, Twig y Paris e Idiorm trabajen juntos muy bien. Slim redireccionará todas las solicitudes a nuestra aplicación aquí, verificará si hay patrones de ruta coincidentes y luego enviará la respuesta adecuada. Este archivo eventualmente contendrá toda nuestra configuración y lógica de la aplicación..

Lo primero que debemos hacer es incluir todas las bibliotecas que harán realidad la magia. Agregue lo siguiente a la index.php archivo de arranque:

  
Si todo va bien, una solicitud a su aplicación no debería hacer absolutamente nada, lo que es genial.!
 
Ahora vamos a poner a Twig en marcha. Usando el paquete de extras Slim podemos dejar que Slim configure un entorno Twig para nosotros. Todo lo que necesita saber es el directorio en el que se encuentra Twig, así que vamos a agregarlo a nuestra rutina de carga. También sigue adelante y crea un directorio de plantillas llamado plantillas en la raíz del sitio mientras estás en ello. 
 
 // Configuración TwigView :: $ twigDirectory = __DIR__. '/ Twig / lib / Twig /';
 
El siguiente componente en nuestra pila es París e Idiorm, nuestro ORM. Utiliza el objeto incorporado de PDO de PHP, por lo que puede usar Postgres o SQLite para su prototipo, pero para este tutorial usaremos MySQL. Asegúrese de darle las credenciales de base de datos adecuadas: 
 
 ORM :: configure ('mysql: host = localhost; dbname = blog'); ORM :: configure ('nombre de usuario', 'raíz'); ORM :: configure ('contraseña', ");
 
Finalmente, pongamos a Slim en marcha. Es bastante complicado, creo que estarás de acuerdo: 
 
 // Empezar Slim. $ app = new Slim (array ('view' => new TwigView));
 
Una palabra de advertencia. Si intenta ejecutar su aplicación ahora, puede obtener un error críptico. ¡No se asuste! Resolveremos eso en un momento agregando algunas rutas..
 
 
 Paso 3: Enrutamiento
 
Agregar rutas en Slim es simple. Todo lo que Slim necesita saber es el método de solicitud de ruta (por ejemplo, GET, POST, PUT, etc.) y el URI para responder, y cómo responder. Primero haremos realidad las rutas básicas de nuestra aplicación y crearemos las entrañas del prototipo más adelante en este tutorial..
 
Vamos a crear una ruta de inicio primero: 
 
 // Blog de inicio. $ app-> get ('/', function () use ($ app) );
 
Aquí le estamos diciendo a Slim que responda a cualquier solicitud GET apuntada a la raíz de nuestra aplicación. El último parámetro de cierre contendrá finalmente la lógica para generar el resultado de la página..
 
Agreguemos otra ruta para ver un artículo de blog individual: 
 
 // Vista del blog. $ app-> get ('/ view / (: id)', función ($ id) use ($ app) );
 
¿Nota la diferencia aquí? En nuestro parámetro URI, hemos añadido una bala (:carné de identidad), que le dice a Slim que espere un valor al final de la URI. 
 
Si alguna vez ha usado cualquier otro marco PHP, probablemente esté familiarizado con este concepto. Si no lo eres, nuestro ejemplo coincidiría. / ver / 1, / vista / 2 etc. 
 
También hemos pasado este parámetro a nuestra función de cierre, para que podamos usarlo también en nuestra lógica de aplicación. Observe cómo también hemos pasado nuestra variable de aplicación al ámbito de cierre, con el utilizar ¿declaración? Esto nos permite acceder a las partes internas de Slim, que utilizaremos para capturar datos de solicitud y generar respuestas.
 
Nuestras rutas de administración necesitarán utilizar diferentes métodos de solicitud, así que vamos a agregarlos en: 
 
 // Admin Home. $ app-> get ('/ admin', function () use ($ app) ); // Admin Add. $ app-> get ('/ admin / add', function () use ($ app) ); // Admin Add - POST. $ app-> post ('/ admin / add', function () use ($ app) ); // Admin Edit. $ app-> get ('/ admin / edit / (: id)', función ($ id) use ($ app) ); // Admin Edit - POST. $ app-> post ('/ admin / edit / (: id)', función ($ id) use ($ app) ); // Admin Eliminar. $ app-> get ('/ admin / delete / (: id)', función ($ id) use ($ app) );
 
Notarás que tenemos algunas rutas POST aquí. Más adelante, los utilizaremos para procesar formularios en nuestro centro de administración..
 
Finalmente, mejor le decimos a Slim que ejecute nuestra aplicación.
 
 $ app-> run ();
 
 
 Paso 4: Modelos
 
Paris e Idiorm facilitan la creación de modelos para representar sus datos, ya que realiza la mayor parte del trabajo duro, lo que es ideal para la creación rápida de prototipos. Almacenaremos nuestros modelos en un directorio llamado modelos, Así que adelante y crea ese directorio. Dentro de ella, crea el básico. Artículo modelo en un archivo llamado Article.php:
 
  
Bastante simple, ¿eh? Paris e Idiorm extraerán toda la información que necesita del nombre de la clase del modelo y la tabla de la base de datos. Mientras estamos en ello, probablemente deberíamos crear la base de datos y agregar algunos datos de muestra: 
 
 CREAR BASE DE DATOS 'blog' CONFIGURACIÓN DE CARACTERES PREDETERMINADOS utf8 COLLATE utf8_general_ci; USE 'blog'; CREAR TABLA SI NO EXISTE 'artículo' ('id' int (10) sin firma NOT NULL AUTO_INCREMENT, 'timestamp' datetime NOT NULL, 'título' varchar (128) NOT NULL, 'resumen' varchar (128) NOT NULL, 'contenido 'text NOT NULL,' author 'varchar (128) NOT NULL, PRIMARY KEY (' id ')) MOTOR = MyISAM DEFAULT CHARSET = utf8; INSERTAR EN 'artículo' ('id', 'marca de tiempo', 'título', 'resumen', 'contenido', 'autor') VALORES (1, '2011-07-28 02:03:14', 'Hola mundo ! ',' Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut ',' Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna Al igual que en el ejercicio y en el ejercicio, se recomienda el ejercicio ulterior y no se excluye el comodo. Se produce un error en la gestión de la voluptuosidad en el corazón de la madre y el niño en la casa de campo. deserunt mollit anim id est laborum. ',' Mr White '), (2,' 2011-07-28 02:03:14 ',' More Hello World! ',' Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed Haga clic aquí para ver más detalles sobre cómo hacer clic aquí para leer el artículo correspondiente. '' Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Lo primero que se puede hacer es usarlo en la mano, pero si lo hacemos, no tenemos que recurrir a ninguna parte de la misma forma. El dolor de cabeza se repite en volumen y volumen en la piel de la madre y de la madre. Excepteur sint occaecat cupidatat no proident, sunt in culpa qui officia deserunt mollit anim id est laborum. ',' Mr Green ');
 
Por último, como usaremos el modelo del artículo en cada página, lo incluiremos en nuestra rutina de carga, justo después de cargar nuestras bibliotecas: 
 
 // Los modelos requieren 'models / Article.php';
 
 
 Paso 5: Aplicación Front End
 
Ahora que tenemos nuestras rutas de aplicación listas y nuestros modelos configurados, es hora de comenzar a construir algunas páginas. Nuestro frente de blog será bastante simple, con una lista de todos los artículos del blog y una página para ver artículos individuales..
 
Usando la interfaz fluida y desechable que París e Idiorm proporcionan, podemos construir rápidamente consultas de base de datos, sin escribir ningún SQL en bruto. Saquemos todos los artículos de la página de inicio utilizando el cierre de la ruta: 
 
 $ articles = Model :: factory ('Artículo') -> order_by_desc ('timestamp') -> find_many ();
 
Comenzamos por llamar al método de fábrica modelo, que dispensará un objeto modelo del tipo Artículo. Desde aquí, tenemos una interfaz fluida, lo que significa que podemos encadenar nuestros comandos. Aquí, obtenemos todos los artículos en la base de datos, ordenados por su marca de tiempo, en orden descendente, y luego le decimos a París que queremos que se devuelvan muchos artículos. El resultado de esta consulta es una matriz de objetos de modelo de artículo..
 
Para que nuestros resultados se muestren en el navegador, necesitamos renderizar una plantilla. Slim proporciona un método de renderizado simple para hacer esto. El primer parámetro es la plantilla a representar, y el segundo parámetro es una matriz asociativa de datos que se pondrá a disposición de la plantilla, que en nuestro caso son los objetos de nuestro artículo..
 
 devuelve $ app-> render ('blog_home.html', array ('articles' => $ articles));
 
Escribiremos nuestras plantillas con Twig, que proporciona una estructura de etiquetas limpia y simple con características de herencia que podemos usar para diseñar fácilmente una página web sin usar PHP. Esto es excelente para la creación de prototipos, ya que significa centrarse en dar forma a la salida de la página, en lugar de vadear a través de PHP y HTML espaguetis entremezclados.
 
Necesitamos un archivo de diseño base: un archivo HTML básico en su carpeta de plantillas llamada layout.html hará.
 
        % block content% % endblock%  
 
Fíjate en las etiquetas de bloques de Twig Los bloques son regiones con nombre que puedes rellenar con contenido. Rellenaremos estos bloques en nuestras plantillas de página individuales..
 
Aquí hay un curso acelerado de Twig para que te pongas en marcha.. 
 
Cualquier variable o expresión dentro de  se escapa automáticamente y se hace eco, mientras que el %% Las etiquetas le permiten usar sentencias de ejecución como, por ejemplo, condicionales o para bucles..
 
Avancemos paso a paso creando la plantilla de la página de inicio del blog. No olvides crear una nueva plantilla llamada blog_home.html en su carpeta de plantillas.
 
Lo primero que queremos que haga nuestra plantilla es extender nuestro diseño. los se extiende La etiqueta le permite a Twig saber que nuestra plantilla se heredará de la layout.html expediente: 
 
 % extiende 'layout.html'%
 
Ahora, podemos usar la misma sintaxis de bloque que usamos anteriormente para completar nuestro diseño. Vamos a configurar el título de la página: 
 
 % block page_title% Mi blog % endblock%
 
Ramita poblará el Título de la página Región en el diseño, con lo que definimos en nuestra plantilla. Para ilustrar aún más el poder de Twig, creemos el bloque de contenido y utilicemos algunas funciones Twig más: 
 
 % block content% % para el artículo en los artículos% % else% 
Actualmente no hay artículos..
 % endif% % endblock%
 
¿Recuerdas que pasamos nuestra matriz de artículos recuperados a nuestra plantilla anteriormente? Esto ahora está disponible en la plantilla con el nombre artículos. Usando las etiquetas lógicas Twigs, pasamos por el artículos variable para comprobar si existe y si no existe, publicamos un mensaje de advertencia cortés. Consolidamos un para bucle y más condicional en un conjunto de etiquetas para manejar fácilmente una matriz vacía.
 
Vamos a mostrar una lista de artículos de blog en la página de inicio para familiarizarnos con la sintaxis de bucle y salida variable de Twig: 
 
 % block content% % para el artículo en los artículos% 
article.title por article.author
 
 Resumen del artículo 
 % else% 
Actualmente no hay artículos..
 % endfor% % endblock%
 
La sintaxis del bucle for es la inversa de la declaración foreach de PHP, simplemente usamos la palabra clave en, en lugar de como. Esto recorre nuestra serie de artículo objetos, haciendo que cada uno esté disponible como una variable llamada artículo dentro del bucle.
 
Dentro del bucle, usamos el  etiquetas, que se hará eco de un valor de escape. Sí, Twig automáticamente se escapa de su salida, así que no hay más escritura htmlentities ()! También accedemos a nuestro atributo de título de artículos usando un punto (.) notación, en lugar de la flecha de PHP habitual (->). Si has escrito Javascript o Python, deberías estar familiarizado con algo de esta sintaxis..
  
Así que ahora que tenemos nuestra página de inicio básica, vamos a ver cómo se ve la vista detallada..
 
 // Vista del blog. $ app-> get ('/ view / (: id)', función ($ id) use ($ app) $ article = Model :: factory ('Article') -> find_one ($ id); if (! $ article instanceof Article) $ app-> notFound (); return $ app-> render ('blog_detail.html', array ('article' => $ article)););
 
Usando París, podemos agarrar rápidamente un artículo por su ID usando el Encuentra uno() método. Si no Artículo se devuelve la instancia de objeto, le informamos a la aplicación Slim que no se encontró la página, lo que automáticamente activará un error 404.
 
Si se encuentra el artículo, lo pasamos a nuestra plantilla de detalles, que tiene el siguiente aspecto:
 
 % extiende 'layout.html'% % block page_title% article.title % endblock% % block content% 
 título del artículo 
 
Publicado: article.timestamp | date ('jS F Y') por article.author
 
article.content
 
Volver a la página de inicio
 % endblock%
 
Usando Twigs filtros incorporados, podemos acceder a algunas funciones básicas de PHP, tales como fecha() en nuestras plantillas. El atributo de clase article.timestamp se asigna automáticamente a nuestro filtro de fecha como primer parámetro, y nuestra cadena de formato de fecha se convierte en el segundo parámetro.
  
Ahora tenemos una parte frontal funcionando, aunque sea simple, pero no tardó en ponerla en funcionamiento. París hace que sea realmente fácil concentrarse en sacar sus datos de la base de datos, y como veremos al crear nuestro centro de administración, también facilita la inserción y actualización de registros.
 
 
 Paso 6: Aplicación Back End
 
Trabajemos en un centro de administración para nuestro blog, que estructuraremos bajo el URI /administración. Viendo que ya tenemos configuradas todas las rutas, escribamos la lógica para la página principal del centro de administración. Será idéntico a nuestra página principal de listas de blogs, por lo que el siguiente código debería tener sentido: 
 
 // Admin Home. $ app-> get ('/ admin', function () use ($ app) $ articles = Model :: factory ('Article') -> order_by_desc ('timestamp') -> find_many (); return $ app- > render ('admin_home.html', array ('articles' => $ articles)););
 
Usaremos un diseño de tabla simple que tiene enlaces de acción para agregar, editar y eliminar artículos de blog.
 
Ya estás familiarizado con el funcionamiento del sistema de región de bloques en Twig, así que concentrémonos en nuestro bloque de contenido: 
 
 % contenido de bloque% 
Mi blog administracion
 
Añadir artículo
 % si articulos%  % para el artículo en artículos%  % endfor% 
 
 
 
Título
 
Fecha
 
Autor
 
Comportamiento
 
 
 
 
 título del artículo 
 
article.author
 
article.timestamp | date ('jS F Y')
 
Editar
 
Borrar
 
 
 % else% 
Actualmente no hay artículos..
 % endif% % endblock%
 
En esta plantilla, estamos usando el % if% % else% % endif% lógica. No queremos mostrar el marcado de la tabla si no hay artículos, por lo que verificamos su existencia antes de decidir qué mostrar. También estamos usando el filtro de fecha  Método de nuevo, lo que creo que estarás de acuerdo es bastante limpio y legible.
  
El centro de administración principal
 
Vayamos a la carne real de nuestro centro de administración: manipulación de contenido. Lo que necesitamos es un formulario que contenga todos los campos que necesitaremos para agregar y editar nuestro artículo. Afortunadamente, Twig es compatible con parciales reutilizables, así que vamos a crear un formulario llamado parcial article_form.html:
 
 
 
action_name Artículo
 
 Título: 
  
 
 Autor: 
  
 
 Resumen: 
 article.summary | default ('') 
 
 Contenido: 
 article.content | default ('') 
 
  
 
 
Un parcial es simplemente una plantilla reutilizable, aún puede contener lógica Twig estándar. En nuestra plantilla de formulario, usamos el defecto filtro, que genera un valor predeterminado si la variable que está filtrando está vacía o no existe. En el caso de nuestros campos de formulario, emitiremos una cadena vacía si ninguno de los atributos del artículo está presente. También estamos esperando dos variables para que nuestro formulario funcione parcialmente. La primera llamada action_name simplemente describe la acción de formulario para nuestros usuarios (es decir, Agregar o Editar) y la segunda action_url se utiliza como la acción de forma.
 
Sin duda, habrá notado cómo la lógica de esta página se divide en dos rutas, una para GET y otra para POST, lo que significa que tendremos que escribir una función para manejar cada método. Nuestra ruta GET solo necesita mostrar la página, nada demasiado complicado. Solo le diremos a Twig que renderice una nueva plantilla: 
 
 // Admin Add. $ app-> get ('/ admin / edit / (: id)', function ($ id) return $ app-> render ('admin_input.html', array ('action_name' => 'Add', 'action_url '=>' / admin / add ')););
 
Pasamos las dos variables esperadas por nuestro formulario parcial en la plantilla. Hablando de eso, déjame explicarte cómo usar el parcial en nuestro admin_input.html modelo: 
 
 % include 'article_form.html'%
 
Estoy seguro de que probablemente adivinaste que sería tan simple, y realmente lo es. Solo necesitamos incluir el parcial dentro de una de nuestras regiones de bloque Twig, y luego aparecerá. También tendrá acceso a todas las variables dentro del alcance de su plantilla principal (es decir, las dos variables que pasamos). Twig tiene algunos excelentes controles de alcance variable y funciones de seguridad de sandboxing, pero es mejor guardarlas para otro día..
 
Nuestra plantilla de entrada final es bastante simple (ver más abajo) y funcionará bien cuando construyamos nuestros controles de edición también. Supongo que se estará preguntando por qué nos molestamos con un parcial en el primer lugar, si nuestras formas de agregar y editar utilizarán la misma plantilla. La razón es porque hace que la reutilización de la forma en otro lugar durante la creación de prototipos sea realmente fácil, si fuera necesario..
 
 % extiende 'layout.html'% % block page_title% action_name Artículo % endblock% % block content% % include 'article_form.html'% % endblock%
  
Añadir un formulario de artículo
 
Vamos a trabajar en esa ruta POST. Lo que debemos hacer es capturar los datos publicados y almacenarlos dentro de un objeto de artículo. No nos molestamos con la comprobación de errores en nuestro ejemplo, ya que solo estamos haciendo un prototipo de nuestra idea. Haremos que París dispense o cree una nueva artículo objeto: 
 
 $ artículo = Modelo :: fábrica ('Artículo') -> crear ();
 
Ahora podemos continuar llenando el artículo a partir de los datos publicados. Tomaremos los datos de POST de nuestro objeto de aplicación Slim, que proporciona un método útil de ayuda a través de su objeto de solicitud: 
 
 $ artículo-> título = $ aplicación-> solicitud () -> publicación ('título'); $ artículo-> autor = $ aplicación-> solicitud () -> publicación ('autor'); $ artículo-> resumen = $ aplicación-> solicitud () -> publicación ('resumen'); $ artículo-> contenido = $ aplicación-> solicitud () -> publicación ('contenido'); $ artículo-> marca de tiempo = fecha ('Y-m-d H: i: s');
 
París se encarga de evitar todas nuestras sugerencias al guardar, lo cual es útil si alguna vez decide poner en escena su prototipo para que otros puedan acceder. Todo lo que tenemos que hacer ahora es decirle a París que guarde el registro.
 
 $ artículo-> guardar ();
 
Finalmente, le decimos a nuestra aplicación Slim que nos lleve de vuelta a la página principal del panel de administración utilizando el redirigir método de ayuda: 
 
 $ app-> redirect ('/ admin');
 
En nuestro método de edición de ruta GET, que es simplemente una amalgama de las cosas que hemos aprendido de la construcción de la página de detalles de nuestro blog y nuestra página de administración de agregados. Primero, debemos cargar el artículo que estamos editando, recuperando el registro con París: 
 
 $ artículo = Modelo :: fábrica ('Artículo') -> find_one ($ id); if (! $ article instanceof Article) $ app-> notFound (); 
 
Paris envía una instancia de un objeto de artículo que coincide con el ID de registro del artículo recibido en nuestro cierre, o falso si no existe ninguno. Luego verificamos si recuperamos una instancia, si no le decimos a Slim que arroje un error 404.
 
Ahora le decimos a Slim que represente la plantilla de entrada, como en nuestra ruta de agregar, pero pasando el objeto del artículo cargado y la URL de acción correcta: 
 
 devolver $ app-> render ('admin_input.html', array ('action_name' => 'Edit', 'action_url' => '/ admin / edit /'. $ id, 'article' => $ article));
 
Nuestra ruta de edición POST funciona casi idéntica a la añadir ruta, con la excepción de que debemos verificar si el artículo se pudo cargar antes de continuar y actualizar sus atributos: 
 
 $ artículo = Modelo :: fábrica ('Artículo') -> find_one ($ id); if (! $ article instanceof Article) $ app-> notFound ();  $ article-> title = $ app-> request () -> post ('title'); $ artículo-> autor = $ aplicación-> solicitud () -> publicación ('autor'); $ artículo-> resumen = $ aplicación-> solicitud () -> publicación ('resumen'); $ artículo-> contenido = $ aplicación-> solicitud () -> publicación ('contenido'); $ artículo-> marca de tiempo = fecha ('Y-m-d H: i: s'); $ artículo-> guardar (); $ app-> redirect ('/ admin');
 
Concluiremos nuestro centro de administración construyendo la ruta de eliminación. Lo haremos al recuperar primero el registro, de manera similar a como lo hicimos en la página de detalles de nuestro blog anteriormente en: 
 
 $ artículo = Modelo :: fábrica ('Artículo') -> find_one ($ id);
 
Si Paris cargó un artículo, debemos eliminarlo y luego enviar al usuario a la página principal de administración. París hace que eliminar un registro sea lo más simple posible: 
 
 if ($ article instanceof Article) $ article-> delete ();  $ app-> redirect ('/ admin');
 
Y con eso se realiza nuestro prototipo básico del centro de administración..
 
 
 Paso 7: Usando Middleware
 
Nuestro centro de administración ya está completado. Es bastante básico ya que solo es un prototipo, pero aún queremos cierta autorización para protegerlo de miradas indiscretas. Slim nos permite insertar middleware en nuestras rutas. Lo que esto significa es que podemos crear funciones que se llaman antes que el cierre de respuesta de nuestras rutas..
 
Podemos usar la autenticación básica de HTTP para proteger nuestro centro de administración. Obviamente, estaríamos usando algo un poco más seguro en un sitio en vivo, pero para nuestro prototipo esto está bien. En lo más alto de nuestra index.php vamos a crear dos constantes que contienen nuestro nombre de usuario y contraseña: 
 
 // Detalles de la autoría. define ('USERNAME', 'admin'); define ('CONTRASEÑA', 'contraseña');
 
Después de crear nuestra instancia de la aplicación Slim, crearemos un cierre, que vincularemos a una variable para mantener nuestra verificación de middleware de autorización: 
 
 // Autentificación. $ authCheck = function () use ($ app) ;
 
Si nunca antes has usado HTTP Basic Auth en PHP, es muy fácil. Podemos usar el $ _SERVER matriz para comprobar qué credenciales se enviaron desde el navegador web del usuario y compararlas con nuestras constantes. Haremos esto dentro de nuestro recién creado cierre. Lo primero que debemos hacer en nuestra función de verificación de autenticación es averiguar si se enviaron las credenciales de autenticación, y si lo fueron, verificar si coinciden con nuestras constantes: 
 
 $ authRequest = isset ($ _ SERVER ['PHP_AUTH_USER'], $ _SERVER ['PHP_AUTH_PW']); $ authUser = $ authRequest && $ _SERVER ['PHP_AUTH_USER'] === USERNAME; $ authPass = $ authRequest && $ _SERVER ['PHP_AUTH_PW'] === PASSWORD;
 
Todo lo que estamos haciendo aquí es verificar si los valores de autenticación existen y coincidir, y luego almacenar los resultados en algunas variables. Suponiendo que alguna de estas variables sea falsa, sabemos que debemos solicitar al usuario que se autorice a sí mismo:
 
 if (! $ authUser ||! $ authPass) $ app-> response () -> header ('WWW-Authenticate: Basic realm = "My Blog Administration"', ''); $ app-> response () -> header ('HTTP / 1.1 401 No autorizado', ''); $ aplicación-> respuesta () -> cuerpo ('
Por favor ingrese las credenciales de administración válidas
'); $ aplicación-> respuesta () -> enviar (); salida; 
 
Verificamos si nuestras credenciales de autenticación están bien. Si no lo están, enviamos una respuesta con los encabezados y el mensaje de advertencia apropiados. Como se vio anteriormente, podríamos acceder al objeto de solicitud de marco Slim para obtener acceso a nuestros datos POST. También podemos acceder al objeto de respuesta interna, lo que nos facilita empujar nuestros encabezados y sobrescribir el cuerpo del objeto de respuesta Slim con un simple mensaje de advertencia HTML, antes de forzar finalmente la secuencia de comandos para salir.
 
En Slim puede agregar múltiples callables a una ruta, y se ejecutan en el orden en que se especifican. Lo que esto significa es que podemos evitar fácilmente el acceso a todas nuestras rutas agregando el cierre de verificación de autenticación antes del cierre de respuesta: 
 
 // Admin Home. $ app-> get ('/ admin', $ authCheck, function () use ($ app) //?); // Admin Add. $ app-> get ('/ admin / add', $ authCheck, function () use ($ app) //?); // Admin Add - POST. $ app-> post ('/ admin / add', $ authCheck, function () use ($ app) //?); // Admin Edit. $ app-> get ('/ admin / edit / (: id)', $ authCheck, uso de la función ($ id) ($ app) //?); // Admin Edit - POST. $ app-> post ('/ admin / edit / (: id)', $ authCheck, uso de la función ($ id) ($ app) //?); // Admin Eliminar. $ app-> get ('/ admin / delete / (: id)', $ authCheck, uso de la función ($ id) ($ app) //?);
 
Y ahí lo tienen, nuestro centro de administración ahora está protegido. Cualquier persona que intente acceder verá un mensaje de advertencia y se le solicitarán sus credenciales.
  
 
 Paso 8: Resumen
 
Esperamos que este tutorial le haya mostrado lo rápido y fácil que es poner en marcha un prototipo con un micro marco, un ORM y un lenguaje de plantillas, mientras se mantiene una buena separación de inquietudes y un código legible.
 
Un potente lenguaje de creación de plantillas puede evitar que sus vistas terminen como una mezcla de código de espagueti HTML y HTML ilegible, y cómo un ORM fluido puede hacer que las acciones de CRUD tediosas sean rápidas y sin dolor.
 
Estas son solo algunas de las muchas cosas geniales que puedes hacer con Slim, Twig y Paris. Si continúa investigando, puede agregar relaciones a sus modelos con Paris, agregar fragmentos de macro en Twig para acelerar el desarrollo de su plantilla y usar enrutamiento basado en nombres con Slim para hacer que la vinculación del contenido de su sitio web y el cambio de las URL sean triviales.
 
Feliz prototipado y muchas gracias por leer.!



		
			
	   
	




Código