Como unir AngularJS y Cordova para generar aplicaciones móviles (parte 2)

Y aquí seguimos… dos entradas seguidas… guau…

Venimos de Como unir AngularJS y Cordova para generar aplicaciones móviles (parte 1) y vamos a continuar donde lo dejamos.

Hasta el momento hemos creado los dos proyectos y unido los archivos base package.json.

Ahora es el momento de continuar.

Para que todo funcione, hay que hacer un par de modificaciones en unos archivos de angular.

En el archivo main.ts del proyecto de angular, hay que modificarlo de tal forma que quede similar al siguiente:

Con esto le indicamos que Angular estara atento al evento onDeviceReady que se generará en la aplicación móvil. Y le indicamos que fije un vigilante (listener) al evento “deviceready”.

Despues, deberemos ir al index.html y efectuar un par de cambios. El primero es cambiar la etiqueta “base” para que la ruta haga referencia al directorio actual donde se encuentre la aplicación (esto tiene sentido ya que utilizará la carpeta donde se instale la aplicación en el dispositivo). Así que hay que hacer que quede así:

Despues debemos añadir la referencia al archivo “cordova.js” que será el encargado de proporcionar la interfaz con todos los plugins de Cordova y al dispositivo.

Con estos pasos ya estaríamos en condiciones de compilar y probar la aplicación, por lo que será necesario instalar todas las dependencias de node, compilar angular, añadir las plataformas a probar en cordova y compilar o correr el proyecto. Los pasos básicamente con los siguientes comandos (1 linea por comando)

Si queremos probar en modo local, se puede ejecutar un servidor local que correrá en el puerto 8000 con

Si tenemos un dispositivo (Android por ejemplo) conectado al pc y con la depuración y demás requisitos instalados, y queremos ejecutar la aplicación sobre el, se puede ejecutar el siguiente comando.

A partir de este punto entramos en las consideraciones para el desarrollo, aquí es donde probablemente haya quien lo haga de forma diferente y mejor. Yo por mi parte para ir haciendo los cambios y poderlos observar lo que hago es situar a angular en modo compilación continua cada vez que detecta cambios en el código fuente con:

Despues arranco el servidor Cordova con el comando anterior serve, y lo que hago es que cada vez que hago algún cambio relevante y quiero probarlo en cordova, ejecuto el comando

O bien si solo voy a colocar una plataforma (Android por ejemplo)

Y después, según la plataforma, o bien ya puedo comprobarlo directamente (en el navegador) o vuelvo a ejecutar el run del dispositivo.

Nota: Un último apunte. Si teneis instalado el sdk de android y teneis algún android virtual, el siguiente comando arranca ese dispositivo virtual para poder efectuar el desarrollo si no teneis uno físico disponible.

En otra entrada continuaré con este desarrollo, y escribiré sobre cómo he conseguido hacer una integración continua con este proyecto, Visual Studio Team Services y HockeyApp, para poder tener Integración continua con el repositorio y poder distribuir las apps que se hagan por los betatesters antes de subirlo a las tiendas. Ese paso también lo abordaré… cuando aprenda a hacerlo jeje…

¡Muchos saludos y gracias por leerme!

Laravel. Implementando CORS

Un pequeño inciso.

Al desarrollar la parte con angular y tratar de realizar el login y que funcione correctamente con la API, os podreis encontrar con el problema de que las peticiones desde el login de angular a la api os den un resultado diciendo que son fallidas porque se piden desde otro recurso (otro servidor, otra ip, etc).

Al final, para sitios de desarrollo, lo mejor es que activeis la cabecera “Access-Control-Allow-Origin” en el servidor que esteis utilizando.

Por ejemplo en apache incluyendo en el htaccess de la api esto:

y ademas, os recomiendo instalaros alguna extensión que os permita manejar el tema de cors a vuestro antojo.

En firefox he instalado esta: https://addons.mozilla.org/en-US/firefox/addon/cors-everywhere/

Y en Google Chrome esta: https://chrome.google.com/webstore/detail/allow-control-allow-origi/nlfbmbojpeacfghkpbjhddihlkkiljbi?hl=es

Si veis que os salen este tipo de errores, antes de maldecir a vuestro servidor o vuestro pc, comprobad esto y al menos dejadlo “libre” en vuestro servidor de desarrollo, en el de producción será otra cosa.

Saludos.

Angular. Entornos (environments)

Antes de continuar con el desarrollo de angular, hemos de colocar un par de cosas.

Hasta este momento hemos estado desarrollando la parte de angular de forma local, es decir, todo funcionaba dentro de la propia app e incluso al compilarla para tenerla en el servidor de producción las rutas y demas factores hacían referencia a rutas “locales”.

Pero para poder empezar a consumir los datos de la api que estamos desarrollando en paralelo en las entradas referidas a Laravel, hemos de comenzar a separar los entornos de “desarrollo” y de “producción”.

En angular, al crear un proyecto, se habrá creado una carpeta y unos archivos llamados “environment”, que serán los que usaremos para poder definir las variables de entorno que vayamos necesitando para el proyecto.

Lo normal es encontrarnos con dos archivos, uno para el entorno de desarrollo, “environment.ts”, y otro para producción, “environment.prod.ts”.

En este momento la unica variable que nos va a hacer falta es la url de nuestra api, por lo que modificaremos los archivos para incluir lo siguiente:

Cambiando “urltoapi” a los valores adecuados para nuestros servidores.

Así que, una vez hechos estos cambios, hasta ahora utilizabamos

Para construir la aplicación, sin embargo a partir de ahora le indicaremos que use el entorno de producción. Sin parámetros usará el archivo “environment.ts” que es el de desarrollo. De esta forma el comando resultante es:

Y si ademas queremos minimizar los archivos para que queden compilados de manera que ocupen lo mínimo posible usaremos:

En estos archivos podremos colocar las variables que necesitemos, a la hora de usarlas será necesario incluir en nuestros archivos de servicios, controladores, etc… el siguiente codigo:

Así podremos utilizar las variables definidas en estos archivos de la forma usual.

Angular. Implementando Login.

Hasta este momento hemos tenido siempre visible nuestra app angular con la parte publica (la que va a ver cualquier usuario que entre a la app).

¿Qué ocurre si vamos a implementar una administración?

Bueno, pues es el momento de empezar a separar cosas y usar las rutas de Angular para el funcionamiento. Lo que vamos a hacer es separar nuestra app, de momento, en tres rutas: “client” (para los visitantes), “login”, para el formulario de entrada a la administración, y “admin” para la administración en si.

Para ello, hay que modificar un poco nuestra aplicación.

Comenzamos por crear un nuevo modulo con ng generate module routes. Con esto generaremos un nuevo archivo en el que vamos a colocar la logica de nuestras rutas de aplicación para que pueda funcionar.

A partir de aquí, tendremos que rellenar todos los campos para que las rutas sean reconocidas y utilizadas en nuestra app. Así que vamos por pasos:

  • routes\routes.module.ts

  • app.component.html. Este únicamente necesita estar compuesto por
  • main.ts. Aquí indicaremos nuestro modulo de rutas y que se utilicen en el inicio del modulo de la app.

  • app.module.ts. Aqui tenemos que declarar las rutas e importarlas para que sean usadas correctamente. Sino habrá errores.

Ahora generaremos los componentes que formarán el login y la entrada a la administración.

  • ng generate component common\login. Con esto generaremos el componente del formulario de login.
  • ng generate component admin\main. Con esto generamos el componente de entrada a la administración.
  • ng generate service services\login. Con esto generaremos el servicio que se encargara de procesar los datos.

Y finalmente los poblaremos. De momento en la clase login está una clase “User” con los datos a pelo, en otra entrega utilizaremos un servicio para consumir los datos de la API que creamos con Laravel para hacer el login.

  • login.service.ts

  • login.component.ts

  • login.component.html

  • main.component.ts

  • main.component.html

Con todos estos pasos, si comprobamos en nuestro navegador (teniendo encendido el servidor de angular de desarrollo, claro, con npm start), podremos ver que las rutas funcionan.

La ruta raíz (“/” o ” “) nos redirige automaticamente a la parte cliente (lo que hemos estado personalizando hasta ahora).

La ruta de administración (“admin”) nos redirige al formulario de login (ruta “login”) si no nos hemos autentifcado, y nos muestra el mensaje de autenticación correcta y el link de logout.

Y con esto estamos en condiciones de ir desarrollando tanto la administración como la parte cliente.

En proximas entradas iremos viendo componentes, servicios y datos necesarios. Tambien volveremos a Laravel cuando haya detalles que impliquen nuevas situaciones con la API.

Muchas gracias por seguir hasta aquí 🙂

Actualizacion: una cosa más, para que funcione en el servidor apache, una vez compilada la web con ng build --prod es necesario que exista un archivo .htaccess con el siguiente contenido. Sino, las rutas no funcionaran:

 

AngularJS. Añadiendo el menú superior.

Una vez que en la entada anterior hemos conseguido que se integre bootstrap con angular, es el momento de comenzar a personalizar la aplicación para nuestros fines.

Como voy a utilizar parte de un desarrollo anterior hecho con Codeigniter, Bootstrap y JQuery, parte del código está ya hecho, solo hay que adaptarlo a nuestra nueva disposición para que se muestre adecuadamente.

Pero antes de empezar, habrá que preparar el entorno. En mi caso he decidido separar las funciones de “frontend” y de “backend”, por lo que voy a generar una estructura de carpetas dentro del proyecto de la forma adecuada. También voy a colocar los recursos del proyecto en una carpeta “assets”, que a su vez tendré separada por los elementos que lo componen y por las dos funciones.

Al final nos encontramos en este momento con una estructura como la siguiente:

Como se puede ver, “assets” está separado en los tipos de elementos (css, js, media), y a su vez “media” está separado en sus tipos de elementos (iconos, imagenes, videos, etc), y dentro de cada una esta dividida por su ámbito de accion (frontend, backend y global). Esta estructura es la elegida por mi, por lo que cada cual puede optar por crear la que quiera, pero para sencillez a la hora de encontrar los elementos, recomiendo que al menos la carpeta “assets” esté creada dentro de la carpeta “src/app”.

Una vez realizado y colocado los elementos que vayamos a utilizar, modificaremos el archivo “nav.component.html” que creamos en la sección anterior para que quede de esta forma:

Nota: cabe aclarar que aún no he colocado las rutas de los enlaces (elementos “a”), por lo que aunque en nuestra app de prueba ya se vean los resultados, los enlaces no funcionan.

Tambien he modificado el archivo index.html, para que muestre de favicon el logotipo adecuado, y no el de angular.

Angularjs: Añadiendo Jquery y Bootstrap.

Vamos a empezar a ver el desarrollo de nuestra webapp para el frontend del proyecto.

En la sección anterior instalamos las herramientas necesarias, y ahora vamos a empezar a modificar para ir viendo los cambios.

Os recomiendo seguir este curso: https://www.udemy.com/curso-de-angular-4-desde-cero-hasta-profesional/. Yo únicamente iré comentando aquí las cosas que sean específicas para el proyecto que estoy desarrollando en estas entradas.

El primer paso para nuestro proyecto, es asegurarnos de que todas las dependencias están colocadas correctamente. Por si acaso no estuvieran, instalamos jquery y bootstrap en nuestro proyecto, de esta forma:

Despues modificaremos nuestro archivo “angular-cli.json” y añadiremos las siguiente dependencias de css en la sección styles:

En este momento, si ejecutamos un “npm start” el proyecto ya tendrá las dependencias colocadas.

Para comenzar, vamos a implementar una plantilla base de boostrap, para ver que todo está correcto. Así que modificaremos el archivo “app.component.html” para que tenga el siguiente contenido:

Y cambiaremos el archivo “styles.css” que incluye con el siguiente contenido:

Con esto habremos personalizado la base, pero ahora vamos a incluir la barra de navegación de bootstrap. Para ello crearemos un nuevo componente con el comando  ng generate component frontend/nav (la parte “frontend” no es necesario incluirlo para que nos genere el componente, pero yo lo incluyo porque voy a diferenciar los componentes que pertencen a la parte “frontend” o “pública” de la app, y a los componentes de una sección “backend” o de “administración”.

Una vez creado el componente nav, lo incluiremos en la web, modificando el archivo “app.component.html” e incluyendo en el  <app-nav></app-nav> antes de la apertura del div “container”, quedando el archivo de esta forma:

Una vez hecho esto, veremos una frase “nav works!” por encima del contenido que teniamos antes.

En este momento modificaremos el archivo “nav.component.html” para que tenga el siguiente contenido:

Y con esto en el navegador podremos comprobar que se ha añadido la barra de navegación con los estilos de bootstrap.

¡Estamos listos para continuar! y empezar a definir los componentes de la parte pública.

Angularjs. Instalando el entorno.

Comenzamos con Angularjs.

A estas alturas ya deberíamos tener instalado nodejs y las herramientas necesarias. Por si acaso, voy a hacer un pequeño resumen (para Windows).

  • Instalar nodejs desde https://nodejs.org/en/. Yo me descargué la versión actual (en el momento de crear esta entrada la 7.10.0)
  • Instalamos la CLI de Angular. Si no estamos seguros de si lo tenemos o no, lo mejor es hacer limpieza primero y reinstalar.
    • Ejecutar npm cache clean.
    • Vaciar el directorio %userdata%\AppData\Roaming\npm\node_modules.
    • Ejecutar npm install -g @angular/cli@latest (así tendremos la ultima versión disponible).
    • Ejecutar npm install -g bower (para tener Bower disponible).
    • Ejecutar npm install -g gulp (para tener disponible Gulp).
    • Ejecutar npm install -g webpack (si queremos webpack en la versión de este momento de forma global).
  • Crearemos el proyecto con ng new web (he llamado web al proyecto de la web con angular… sigo siendo original).

Una vez instalado todos los elementos, con npm start desde una consola se compilará y ejecutará un miniservidor web local para empezar a desarrollar nuestra app con Angular.

Laravel 5.4. Middlewares

Hasta el momento, y siguiendo la serie de entradas de Laravel, hemos conseguido que nuestra api tenga el modulo CRUD de usuarios, y que esté securizada para que solo los usuarios que tengan el token adecuado funcione.

Ahora es el momento de añadir un paso más en la securización de nuestra aplicación Laravel, en este caso adaptar las peticiones para que únicamente los usuarios con un rol/nivel adecuado puedan ejecutar según qué funciones.

Los middleware, son funciones que nos permiten agregar filtros a cada petición HTTP realizada por un usuario en una aplicación. La finalidad de este componente es disminuir la carga de trabajo en los controladores y proporcionar una solución mucho más simple y estándar a la hora de aplicar las restricciones necesarias en el proyecto.

Lo primero será crear el Middleware que vamos a utilizar, en este caso LevelMiddleware.

Qué nos generará un archivo como el siguiente:

De momento no hace nada más que mandar la petición ($request) al siguiente elemento dentro del framework para que sea tratado. Más adelante lo modificaremos.

Pero antes, vamos a incluirlo en la aplicación para que se pueda utilizar cuando se hagan las llamadas adecuadas. Para esto, incluiremos nuestro Middleware en el archivo Kernel.php, en las zonas adecuadas, en este caso en el array $routeMiddleware, quedando así:

Y modificaremos el archivo de rutas “web.php” para incluir este middleware en las peticiones de la api que no sean la del login, en este momento la del grupo de usuarios, quedando este grupo asi:

Con esto ya estará colocado para que funciones nuestro middleware, y se ejecutará despues de que se haya ejecutado el de “auth:api”, que definimos anteriormente para que sea el verificador de token.

Si quereis ver que se ejecuta el middleware, antes de empezar a modificarlo, probar con un cliente rest alguna de las rutas anteriores, y añadid esta linea en el archivo “LevelMiddleware.php”, antes del return que se creó por defecto:

Vereis que al ejecutarlo os devuelve el error de “notlevel”.

Y a partir de aquí, tras modificarlo adecuadamente, se podrá utilizar para que las funciones que se deseen estén limitadas por el nivel del usuario, proporcionando la separación para nuestra aplicación.

Laravel 5.4: Securizando la API

Bueno, de las entradas anteriores ya tenemos listo el CRUD de usuarios y las rutas para las llamadas.

Ahora voy a seguir las indicaciones de https://styde.net/api-rest-con-laravel-5-1-proteccion-con-access-key/ para poder securizar la API.

Una vez seguidos los pasos de este tutorial para generar la access key de toda la aplicación y securizarla de manera que nadie que no tenga esa clave la pueda utilizar, es el momento de generar la llamada de login para que un usuario pueda loguearse en la aplicacion con una llamada y recibir un access token que le sirva para poder utilizarla.

Cuándo se creó la tabla de usuarios, se añadió un campo de “api_token” que se autogeneraba cuando se guardaba el usuario por primera vez, así que ahora es el momento de generar la llamada de login. Si recordais del paso anterior, en el archivo “routes/web.php” ya incluimos la ruta de login, para estas llamadas.

También os puede pasar que, despues de seguir los pasos del tutorial de styde.net, os esteis encontrando que las llamadas os devuelven un 401 not authorized si intentais las llamadas sin incluir el access token que ahí está generado.

Pero vamos por pasos. Lo primero es generar el controlador y el modelo que usaremos para el login

E incluir la función login() en la clase del controlador, y el modelo, por lo que quedaría así:

Si estamos siguiendo los pasos, ahora mismo al probar la url de login nos pueden pasar dos cosas: o bien nos de el ok sin contenido, o bien nos de un 401 not authorized. Esto ultimo se debe a la comprobación que hace la clase “VerifyAccessKey” que generamos para securizar la API. Lo que tenemos que conseguir es que no haga esta comprobación si las rutas de uso son “/” o “/v1/login”.

Para ello, tendremos que modificar lo siguiente (o al menos lo que a mi me ha funcionado):

En App\Http\Kernel.php, ha quedado así:

En App\routes\web.php, modifcar el grupo para el prefijo “v1”, ha quedado así:

En App\Http\Middleware\VerisyCsrfToken.php, añadir al array $except la ruta de login:

Ya tenemos la api segura para las llamadas que no sean la raíz y el login. Ahora es el momento de que ese login haga algo. Únicamente va a tener una funcion login para hacer la petición, y devolverá 3 datos para que sean guardados en la sesión del usuario.

LoginController.php

Models/Login.php

Con esto ya tenemos hecho el login y el usuario recibe un token para poder interactuar después con el resto de la API.

En este punto, hemos de cambiar el verificador de token. Al final queda de esta forma:

Y tras esto habra que modificar y probar adecuadamente el controlador de usuarios para ver que todas las llamadas se producen correctamente y ver que si no está el token no funciona y no autoriza a efectuar la operación.

Por hoy es suficiente…

Laravel 5.4. API. Rutas de la aplicación

Continuemos.

Ahora es el momento de preparar las rutas de la aplicación que van a hacer que la magia funcione.

Para ello, en Laravel disponemos de los archivos situados en la carpeta “routes”, que de momento los que nos interesan son los archivos “api.php” y “web.php”. La diferencia entre cada uno de ellos es que la ruta de acceso será diferente, para la api todas las rutas incluirán al inicio la ruta “/api/” y los de web no la incluirán.

Dicho esto, y para separar mejor las rutas de la api y las diferentes modifcaciones, voy a tomar la costumbre de nombrar las llamadas con la versión de la API que utilice, “v1”, “v2”, etc… así será más sencillo luego a la hora de documentarlo.

Bien, para incluir todas las rutas del manejo de usuarios creadas en el anterior post, hemos de incluir en el archivo “web.php” lo siguiente:

Y modificando o añadiendo las rutas que queramos podremos ir montando nuestra api con los modulos necesarios.

Laravel 5.4: Comenzando API. CRUD Usuarios

Continuamos con este “cursillo – aprendizaje” sobre crear una aplicación con Laravel y Angular.

Lo primero con lo que vamos a comenzar es con las operaciones CRUD básicas para los usuarios de la aplicación.

Lo primero será crear el controlador que usaremos para estas funciones, para lo que será necesario ejecutar el siguiente comando:

Con el modificador  –resource conseguiremos que nos cree el controlador con un esqueleto basico de todas las funciones básicas para el manejo de los usuarios (aparte de las CRUD, las necesarias para manejar las vistas y formularios relacionados con la creación, update, etc).

Una vez conseguido esto, editaremos el archivo routes\web.php y añadiremos lo siguiente:

(si, de momento lo vamos a meter en la ruta web, para irlo probando, más adelante lo ingresaremos en una api con autenticación).

Con este código conseguimos que se reconozcan las rutas necesarias para las operaciones. Como en este caso estamos creando una api que no tendrá “vistas” (formularios o webs que ver) podemos obviar rutas y decirle que únicamente utilice las relativas al CRUD.

También hemos de crear el modelo. En este momento voy a ir creando modelos (aunque se pueden usar factorías y demás opciones, eso ya lo dejo de momento a la investigación de cada uno, o para más adelante). Para ello el comando es

Nota: un apunte, si ejecutamos directamente el comando de crear modelo con el modificador resource, como en el controlador, ya nos creara el modelo y el controlador enlazados (lo cual nos agilizará un poco estos pasos)

Y ahora hay que meterse en harina.

Con el siguiente comando podemos ver una lista de las rutas que están incluidas en este momento. Así veremos los métodos y opciones que se van a utilizar para las operaciones.

Y ahora se tratará de ir modificando las funciones en el controlador y o el modelo para ir adaptando el control de usuarios.

Dejo por ejemplo el código (sin finalizar) de la función de guardar un usuario

Tras modificar todas las funciones, estaremos listos para el siguiente paso Smile

Laravel 5.4 y Angular 4. Base de datos.

Continuamos con esta serie de entradas de un proyecto con Laravel.

Dado que voy a utilizar Laravel como backend y voy a generar una API REST con este framework, es hora de prepararlo.

Así que vamos con ello.

Preparando la base de datos.

Lo primero de todo proyecto es preparar la base de datos.

En estas lides nos va a resultar muy útil el sistema de “migraciones” (migrates) y “semillas” (seeds) de Laravel.
No me voy a detener mucho tiempo en definir que son, para eso recomiendo mirar la documentación.

User Migrate.

Para empezar, al menos en este proyecto, modificaremos el archivo “2014_10_12_000000_create_users_table.php”, que es un archivo de migración que se copia al iniciar el proyecto con composer para generar la tabla de usuarios, y ya que está, para que complicarnos.
No pongo todos los campos que voy a utilizar en la vase de datos, únicamente alguno o los no relevantes.
Todas las migraciones tienen dos funciones, la función up() y la down(), que son las acciones al crear la base de datos o cuando se hace algún rollback, respectivamente. En la función up() incluiremos lo siguiente:

Levels Migrate

En mi caso, y para la aplicación, voy a incluir un sistema de niveles, por lo que es necesario una tabla que guarde los niveles a utilizar.
Para crear el migrate que se encargará de crear la base de datos.

Una vez creado, le generaremos los campos necesarios (idlevel y name) en el código de la misma manera que para el usuario.

En este caso, lo más recomendable es insertar algunas filas, para lo que será necesario que utilicemos los seeders de Laravel para rellenar esos huecos.

Para empezar, crearemos un Seeder, que se guardará en la carpeta Database/seeds

Una vez creado, al entrar a modificarlo observaremos que únicamente tiene la función run(), donde se ejecutarán los procesos que rellenaran las filas de la tabla.

Aquí en este caso, voy a incluir los registros necesarios (ya que mi plan para esta tabla es un numero finito y relativamente asequible de mantener), aunque se puede automatizar con Factorias. Así que, de momento, incluiré el siguiente código:

Nota: que no se os olvide incluir el uso de Carbon en esta clase, porque sino no funcionará. Añadid

al inicio del archivo, en la sección de uses.

Una vez generado el archivo del seed, es necesario indicar que se ejecutará. Para ello, lo primero es modificar el archivo “App\Database\seeds\DatabaseSeeder.php”, en el cual hay que añadir la clase seed que acabamos de crear, así que dentro de la función run de este archivo incluiremos una línea por cada seeder que queramos ejecutar:

Una vez hecho todo esto, para ejecutar estos seeds hay tres formas principales:

O bien ejecutarlo cuando se hace un migrate:refresh (explicado debajo).

Utilizando migrates y seeds

Ahora es el momento de hacer que Laravel ejecute estas migraciones y rellenos de datos.

Para ello, el comando a ejecutar es :

Para que se ejecuten los seeds es necesario ejecutar el siguiente:

Pero si quereis regenerar la base de datos completa e incluir los cambios, lo mejor es ejecutar:

Esto hará que se reinicie todos los campos y migraciones de la base de datos.

Nota: es posible que os dé un error, en estos casos antes del migrate:refresh o de ejecutar los seeds, es recomendable ejecutar lo siguiente:

Para que se regenere el árbol de clases que utilizará luego artisan.

Conclusión

De esta forma, y tras generar todos los migrates y seeds necesarios para todos los campos y tablas de la base de datos que vaya a utilizar nuestra aplicación, estaremos preparados para poder empezar a meternos en harina para generar las rutas, controladores, modelos, etc, que va a necesitar nuestra aplicación.

Qué seguiremos con ello en el siguiente capítulo.

Gracias por seguir hasta aquí 😉