Estructura del Proyecto:

Todos los proyectos nuevos en Laravel tienen la siguiente estructura de directorios:

A continuación, describiremos los directorios y archivos más importantes para que nos ayuden a
entender más el funcionamiento del framework.

El directorio app
App es usado para ofrecer un hogar por defecto a todo el código personal de tu proyecto. Eso incluye
clases que puedan ofrecer funcionalidad a la aplicación, archivos de configuración y más. Es
considerado el directorio más importante de nuestro proyecto ya que es en el que más
trabajaremos.

El directorio app tiene a su vez otros subdirectorios importantes, pero uno de los más utilizados es
el directorio Http en el cuál ubicaremos nuestros Controllers, Middlewares y Requests en sus
carpetas correspondientes, además dentro del subdirectorio Http encontremos también el archivo
web.php donde escribiremos las rutas de la aplicación.

A nivel de la raíz del directorio app encontraremos el modelo User.php, los modelos comúnmente
se ubicarán a nivel de la raíz de la carpeta app aunque igual es posible estructurarlos de la forma
que queramos, por ejemplo, en una carpeta llamada Models.

El directorio config
La configuración tanto para el framework como para tu aplicación se mantiene en este directorio.
La configuración de Laravel existe como un conjunto de archivos PHP que contienen matrices clave-
valor. Entre los archivos más usados del directorio config se encuentran:
  app.php: En este archivo nos puede interesar configurar el lenguaje de nuestra aplicación,
la zona horaria, los providers y aliases de las clases más comunes.
 database.php: En este archivo podemos configurar principalmente el motor de base de
datos al cuál deseamos conectarnos.

El directorio database
Aquí se encontraran los archivos relacionados con el manejo de la base de datos. Dentro de este
directorio se encuentran los subdirectorios:

 factories: Aquí escribiremos nuestros model factories.

 migrations: Todas las migraciones que creamos se ubican en este subdirectorio.
 seeds: Contiene todas las clases de tipo seed.

El directorio public
Dentro de este directorio colocaremos todos los recursos estáticos de nuestra aplicación, es decir,
archivos css, js, imágenes y fuentes.

Es recomendable crear una carpeta por cada tipo de recurso.

El directorio resources
Dentro de este directorio se encuentran los subdirectorios:

 assets: Aquí se ubican todos los archivos less de nuestra aplicación (útil para desarrolladores
front-end).
 lang: Aquí se encuentran todos los archivos de internacionalización, es decir, los archivos
para poder pasar nuestro proyecto de un idioma a otro. Normalmente habrá una carpeta
por cada idioma, ejemplo:
o en: idioma inglés
o es: idioma español
 views: Aquí ubicaremos nuestras vistas en formato php o php.blade, es recomendable crear
una carpeta por cada controlador, además agregar una carpeta templates para las plantillas.
Una plantilla es una vista general, que tiene segmentos que pueden ser reemplazados
mediante la herencia de plantillas, más adelante se hablará de este tema.

El directorio storage
Cuando Laravel necesita escribir algo en el disco, lo hace en el directorio storage . Por este motivo,
tu servidor web debe poder escribir en esta ubicación. Aquí podemos encontrar otros directorios
entre los cuales el más relevante es el subdirectorio framework, es ahí donde se almacena el cache
y las vistas compiladas.

El directorio tests
Aquí escribiremos los archivos de pruebas que serán ejecutadas posteriormente por phpunit.
El archivo .env y .env.example
El archivo .env no existe cuando instalamos laravel, en este archivo se configurará el modo en que
se ejecuta nuestra aplicación, por defecto será el modo debug, además podemos configurar la
conexión a la base de datos y la conexión con el servidor de correo electronico. El archivo .env lo
creamos copiando el archivo .env.example y renombrando la copia como .env.

Por motivos de seguridad de la base de datos el archivo .env nunca se sube cuando hacemos un
push en nuestro repositorio. Es por eso que aparece escrito dentro del archivo .gitignore en la raíz
de nuestro proyecto.
Instalación de Laravel:
1. Crear Carpeta para el Proyecto (PryPrueba).
2. Ir a la carpeta del Proyecto e instalar Laravel:

3. Aquí cambiamos nombre de nuestra aplicación en la carpeta

app/Http/Controllers/Controller.php:

4. Vamos a darle la configuración general:

a. Vamos a la carpeta Config/app.php y en el modo debug lo activamos.

b. Para Determinar la Zona Horaria:

c. Aquí definimos el lenguaje que utilizaremos el proyecto, ya que, por defecto esta
en inglés, entonces para que nuestro proyecto trabaje con el idioma español
creamos una carpeta en el directorio resources/lang que se llamara “es” y creamos
nuestros archivos: auth.php, pagination.php, passwords.php, validation.php.
auth.php:
<?php
return [
/*
|--------------------------------------------------------------------------
| Authentication Language Lines
|--------------------------------------------------------------------------
|
| The following language lines are used during authentication for various
| messages that we need to display to the user. You are free to modify
| these language lines according to your application's requirements.
|
*/
'failed' => 'Estas credenciales no coinciden con nuestros registros.',
'throttle' => 'Demasiados intentos de inicio de sesión. Vuelva a intentarlo
en :seconds segundos.',
];
pagination.php:
<?php
return [
/*
|--------------------------------------------------------------------------
| Pagination Language Lines
|--------------------------------------------------------------------------
|
| The following language lines are used by the paginator library to build
| the simple pagination links. You are free to change them to anything
| you want to customize your views to better match your application.
|
*/
'previous' => '&laquo; Anterior',
'next' => 'Siguiente &raquo;',
];
passwords.php:
<?php
return [
/*
|--------------------------------------------------------------------------
| Password Reminder Language Lines
|--------------------------------------------------------------------------
|
| The following language lines are the default lines which match reasons
| that are given by the password broker for a password update attempt
| has failed, such as for an invalid token or invalid new password.
|
*/
'password' => 'La contraseña debe tener al menos 6 caracteres y coincidir
con la confirmación.',
'reset' => '¡Su contraseña ha sido restablecida!',
'sent' => '¡Recordatorio de contraseña enviado!',
'token' => 'Este token de restablecimiento de contraseña es inválido.',
'user' => 'No se ha encontrado un usuario con esa dirección de correo.',
];
validation.php:
<?php
return [
/*
|--------------------------------------------------------------------------
| Validation Language Lines
|--------------------------------------------------------------------------
|
 | The following language lines contain the default error messages used
by
| the validator class. Some of these rules have multiple versions such
| as the size rules. Feel free to tweak each of these messages here.
|
*/
'accepted' => 'El campo :attribute debe ser aceptado.',
'active_url' => 'El campo :attribute no es una URL válida.',
'after' => 'El campo :attribute debe ser una fecha posterior a
:date.',
'after_or_equal' => 'El campo :attribute debe ser una fecha posterior
o igual a :date.',
'alpha' => 'El campo :attribute sólo puede contener letras.',
'alpha_dash' => 'El campo :attribute sólo puede contener letras,
números y guiones (a-z, 0-9, -_).',
'alpha_num' => 'El campo :attribute sólo puede contener letras y
números.',
'array' => 'El campo :attribute debe ser un array.',
'before' => 'El campo :attribute debe ser una fecha anterior a
:date.',
'before_or_equal' => 'El campo :attribute debe ser una fecha anterior
o igual a :date.',
'between' => [
'numeric' => 'El campo :attribute debe ser un valor entre :min y :max.',
'file' => 'El archivo :attribute debe pesar entre :min y :max kilobytes.',
'string' => 'El campo :attribute debe contener entre :min y :max
caracteres.',
'array' => 'El campo :attribute debe contener entre :min y :max
elementos.',
],
'boolean' => 'El campo :attribute debe ser verdadero o falso.',
'confirmed' => 'El campo confirmación de :attribute no coincide.',
'date' => 'El campo :attribute no corresponde con una fecha
válida.',
'date_format' => 'El campo :attribute no corresponde con el formato
de fecha :format.',
'different' => 'Los campos :attribute y :other deben ser diferentes.',
'digits' => 'El campo :attribute debe ser un número de :digits
dígitos.',
'digits_between' => 'El campo :attribute debe contener entre :min y
:max dígitos.',
'dimensions' => 'El campo :attribute tiene dimensiones inválidas.',
'distinct' => 'El campo :attribute tiene un valor duplicado.',
 'email' => 'El campo :attribute debe ser una dirección de correo
válida.',
'exists' => 'El campo :attribute seleccionado no existe.',
'file' => 'El campo :attribute debe ser un archivo.',
'filled' => 'El campo :attribute debe tener algún valor.',
'image' => 'El campo :attribute debe ser una imagen.',
'in' => 'El campo :attribute es inválido.',
'in_array' => 'El campo :attribute no existe en :other.',
'integer' => 'El campo :attribute debe ser un número entero.',
'ip' => 'El campo :attribute debe ser una dirección IP válida.',
'ipv4' => 'El campo :attribute debe ser una dirección IPv4 válida.',
'ipv6' => 'El campo :attribute debe ser una dirección IPv6 válida.',
'json' => 'El campo :attribute debe ser una cadena de texto JSON
válida.',
'max' => [
'numeric' => 'El campo :attribute no debe ser mayor a :max.',
'file' => 'El archivo :attribute no debe pesar más de :max kilobytes.',
'string' => 'El campo :attribute no debe contener más de :max
caracteres.',
'array' => 'El campo :attribute no debe contener más de :max.',
],
'mimes' => 'El campo :attribute debe ser un archivo de tipo
:values.',
'mimetypes' => 'El campo :attribute debe ser un archivo de tipo
:values.',
'min' => [
'numeric' => 'El campo :attribute debe tener al menos :min.',
'file' => 'El archivo :attribute debe pesar al menos :min kilobytes.',
'string' => 'El campo :attribute debe contener al menos :min
caracteres.',
'array' => 'El campo :attribute debe contener al menos :min
elementos.',
],
'not_in' => 'El campo :attribute seleccionado es inválido.',
'not_regex' => 'El formato del campo :attribute es inválido.',
'numeric' => 'El campo :attribute debe ser un número.',
'present' => 'El campo :attribute debe estar presente.',
'regex' => 'El formato del campo :attribute es inválido.',
'required' => 'El campo :attribute es obligatorio.',
'required_if' => 'El campo :attribute es obligatorio cuando el campo
:other es :value.',
'required_unless' => 'El campo :attribute es requerido a menos que
:other se encuentre en :values.',
 'required_with' => 'El campo :attribute es obligatorio cuando :values
está presente.',
'required_with_all' => 'El campo :attribute es obligatorio cuando :values
está presente.',
'required_without' => 'El campo :attribute es obligatorio cuando :values
no está presente.',
'required_without_all' => 'El campo :attribute es obligatorio cuando
ninguno de los campos :values está presente.',
'same' => 'Los campos :attribute y :other deben coincidir.',
'size' => [
'numeric' => 'El campo :attribute debe ser :size.',
'file' => 'El archivo :attribute debe pesar :size kilobytes.',
'string' => 'El campo :attribute debe contener :size caracteres.',
'array' => 'El campo :attribute debe contener :size elementos.',
],
'string' => 'El campo :attribute debe ser una cadena de caracteres.',
'timezone' => 'El campo :attribute debe contener una zona válida.',
'unique' => 'El valor del campo :attribute ya está en uso.',
'uploaded' => 'El campo :attribute falló al subir.',
'url' => 'El formato del campo :attribute es inválido.',
/*
|--------------------------------------------------------------------------
| Custom Validation Language Lines
|--------------------------------------------------------------------------
|
| Here you may specify custom validation messages for attributes using
the
| convention "attribute.rule" to name the lines. This makes it quick to
| specify a specific custom language line for a given attribute rule.
|
*/
'custom' => [
'attribute-name' => [
'rule-name' => 'custom-message',
],
],
/*
|--------------------------------------------------------------------------
| Custom Validation Attributes
|--------------------------------------------------------------------------
|
| The following language lines are used to swap attribute place-holders
| with something more reader friendly such as E-Mail Address instead
| of "email". This simply helps us make messages a little cleaner.
 |
*/
'attributes' => [],
];
d. Y luego el lenguaje de nuestro proyecto se trabajará en español:

5. Servidor de desarrollo local: Si tiene PHP instalado localmente y desea usar el servidor de
desarrollo incorporado de PHP para servir su aplicación, puede usar el comando:

Este comando iniciará un servidor de desarrollo en: http://localhost:8000 o

http://127.0.0.1:8000

Rutas:
Hace referencia a las URL’s de tu aplicación. Se configura en el directorio de nuestro proyecto en
routes/web.php

Las rutas de nuestra aplicación se tienen que definir en el fichero routes/web.php. Este es el punto
centralizado para la definición de rutas y cualquier ruta no definida en este fichero no será válida,
generado una excepción (lo que devolverá un error 404).

Pueden devolver directamente un valor desde el propio fichero de rutas, pero también podrán
generar la llamada a una vista o a un controlador.
Rutas Básicas:

Las rutas, además de definir la URL de la petición, también indican el método con el cual se ha de
hacer dicha petición. Los dos métodos más utilizados y que empezaremos viendo son las peticiones
tipo GET y tipo POST.

Este código se lanzaría cuando se realice una petición tipo GET a la ruta.

Añadir rutas con Parámetros:

Si queremos añadir parámetros a una ruta simplemente los tenemos que indicar entre llaves {} a
continuación de la ruta, de la forma:
En este caso definimos la ruta /nombre/{nombre}, donde nombre es requerido y puede ser
cualquier valor. El parámetro se le pasará a la función, el cual se podrá utilizar (como veremos más
adelante) para por ejemplo obtener datos de la base de datos, almacenar valores, etc.

También podemos indicar que un parámetro es opcional simplemente añadiendo el símbolo ? al

final (y en este caso no daría error si no se realiza la petición con dicho parámetro):

Laravel también permite el uso de expresiones regulares para validar los parámetros que se le pasan
a una ruta. Por ejemplo, para validar que un parámetro esté formado solo por letras o solo por
números:

 Validación de letras:

Si ponemos una letra:

Si ponemos un numero:
 Validación de Números:

Si ponemos un numero:

Si ponemos una letra:

Si ponemos dos parámetros:

Si ponemos algo erróneo:

Controladores:
Esto nos permitirá separar mucho mejor el código y crear clases (controladores) que agrupen toda
la funcionalidad de un determinado recurso.

Los controladores están en la carpeta app/Http/Controllers, normalmente se les añade el sufijo

Controller

Para crear un controlador se usa el siguiente código en el terminal:

 Para crear un controlador vacio.

Creamos el método en el PruebaController.php

Todos los controladores tienen que extender la clase base Controller. Esta clase viene ya creada por
defecto con la instalación de Laravel, la podemos encontrar en la carpeta app/Http/Controllers.

Se utiliza para centralizar toda la lógica que se vaya a utilizar de forma compartida por los
controladores de nuestra aplicación. Por defecto solo carga código para validación y autorización,
pero podemos añadir en la misma todos los métodos que necesitemos.

En la clase nos encontramos con el namespace, es una especie de ruta que se utiliza para no crear
conflictos con otras clases, métodos o variables que puedan ir creando los usuarios.

Use, sirve para importar diferentes clases que se encuentran en bibliotecas, ya que tienen clases
que utilizan más adelante.

Configuramos en el routes/web.php:

Una vez definido un controlador ya podemos asociarlo a una ruta. Para esto tenemos que modificar
el fichero de rutas web.php de la forma:
En lugar de pasar una función como segundo parámetro, tenemos que escribir una cadena que
contenga el nombre del controlador, seguido de una arroba @ y del nombre del método que
queremos asociar. No es necesario añadir nada más, ni los parámetros que recibe el método en
cuestión, todo esto se hace de forma automática.

Controladores con resources:

El enrutamiento de recursos de Laravel asigna las rutas "CRUD" típicas a un controlador con una
sola línea de código.

Creamos una clase controlador llamado Ejemplo1:

Aquí se crea el controlador con sus métodos CRUD:

A continuación, puede registrar una ruta ingeniosa para el controlador en el routes/web.php:

Probamos:
Vistas:
Las vistas son la forma de presentar el resultado (una pantalla de nuestro sitio web) de forma visual
al usuario, el cual podrá interactuar con él y volver a realizar una petición. Las vistas además nos
permiten separar toda la parte de presentación de resultados de la lógica (controladores) y de la
base de datos (modelos). Por lo tanto, no tendrán que realizar ningún tipo de consulta ni
procesamiento de datos, simplemente recibirán datos y los prepararán para mostrarlos como HTML.

Las vistas están en la carpeta resources/views como ficheros PHP, y por lo tanto tendrán la
extensión .php. Contendrán el código HTML de nuestro sitio web, mezclado con los assets (CSS,
imágenes, Javascripts, etc. que estarán almacenados en la carpeta public) y algo de código PHP (o
código Blade de plantillas, como veremos más adelante) para presentar los datos de entrada como
un resultado HTML.

Aquí creamos nuestro index.php:

Una vez que tenemos una vista tenemos que asociarla a una ruta para poder mostrarla. Para esto
tenemos que ir al fichero routes/web.php como hemos visto antes y escribir el siguiente código:

En este caso estamos definiendo que la vista se devuelva cuando se haga una petición tipo GET a
la raíz de nuestro sitio. El único cambio que hemos hecho con respecto a lo que vimos en la
sección anterior de rutas ha sido en el valor devuelto por la función, el cual genera la vista usando
el método view y la devuelve. Esta función recibe como parámetros:

 El nombre de la vista (en este caso home), el cual será un fichero almacenado en la carpeta
views, acordaros que la vista anterior de ejemplo la habíamos guardado en
resources/views/index.php. Para indicar el nombre de la vista se utiliza el mismo nombre
del fichero pero sin la extensión .php.
 Como segundo parámetro recibe un array de datos que se le pasarán a la vista. En este caso
la vista recibirá una variable llamada $nombre con valor "Jose Carlos".
Como hemos visto para referenciar una vista únicamente tenemos que escribir el nombre del
fichero que la contiene pero sin la extensión .php. En el ejemplo, para cargar la vista almacenada en
el fichero index.php la referenciamos mediante el nombre home, sin la extensión .php ni la ruta
resources/views.

Blade:
Blade es un motor(constructor) de plantillas que viene con laravel, que sirve para crear vistas de
forma sencilla y limpia que va reutilizando código, así de evitar etiquetas php y html. Modularizando
nuestros sitios web en pequeños módulos o partes.

Ejemplo:

1. Primero creamos en la carpeta resources/views la carpeta layouts.

2. Creamos la clase donde será nuestra plantilla se llamará plantilla.blade.php
3. Luego creamos dos clases que será parte de nuestra plantilla: contacto.blade.php y
galeria.blade.php.
4. En plantilla.blade.php construiremos nuestra plantilla.
5. En contacto.blade.php construiremos los contenidos

Con @yield(‘nombre’), esta sentencia nos permite declarar un futuro section de nuestro
HTML que se definirá en las vistas que son heredadas y no puede agregarse algún tipo de
contenido por defecto, este sólo se usa en archivos que toman el rol de Template .
Con @extends(‘nombre_template’), esta sentencia nos ayuda a decirle a una vista cual va
a ser el template que se va a usar.
Con @section(‘nombre’), esta sentencia nos permite declarar como su nombre lo dice una
sección dentro del template que puede tener un contenido por defecto que si no es
redefinido en la vista que herede el template entonces aparecerá.
6. Luego creamos en el app/Http/Controllers/PruebaController.php la función:

7. En el routes/web.php ruteamos:
8. En galeria.blade.php construiremos los contenidos

9. Luego creamos en el app/Http/Controllers/PruebaController.php la función:

10. En el routes/web.php ruteamos:

Base de datos con Laravel: