Laravel: Modelos, Eloquent y uso de Tinker (parte 8)

Definiciones

  • ORM: Modelo de programación que permite mapear las estructuras de una base de datos relacional (en nuestro ejercicio, MySQL), sobre una estructura lógica de entidades para simplificar y acelerar el desarrollo. Las estructuras de la base de datos quedan vinculadas con las entidades lógicas o base de datos virtual definida en el ORM, de tal modo que las acciones CRUD (CreateReadUpdateDelete) se realizan de forma indirecta por medio del ORM. Así, realizar consultas a la base de datos se puede hacer sin escribir código SQL, sino utilizando objetos y métodos.
  • Modelos: En Laravel crearemos un modelo por cada una de las tablas que queramos administrar. Existe una convención para el nombre de las tablas y los modelos, ya que éstos tendrán el nombre en singular para un nombre de tabla en plural (en inglés). Siempre podemos crear una variable de tipo protected dentro de la clase del modelo para especificar otro nombre de tabla, si fuera necesario no seguir la convención.
  • Eloquent: El ORM que incluye Laravel.
  • Tinker: es una herramienta para ejecutar código php en la consola de Laravel, con la que podemos hacer pruebas de funcionamiento, y también podemos usar la directivas de Eloquent.

Vamos a ejercitarnos con el uso de Tinker, una herramienta que nos permite ejecutar el consola acciones sobre la base de datos mediante el ORM, instanciando objetos y llamado a sus métodos. Para ejecutar Tinker, en consola:

php artisan tinker

Para salir de Tinker, simplemente ejecutamos exit.

Antes de continuar, vamos a crear un modelo para la tabla «cursos», por lo que lo llamamos Curso siguiendo la convención:

php artisan make:model Curso

Ya tenemos nuestro archivo dentro de la capeta Models.

Insertar registros en la base de datos

  • Llamamos al modelo con el comando use y su namespace
  • Crear una instancia del objeto con el comando new
  • Agregar propiedades a los métodos
  • Salvar con save; si queremos guardar los registros en la base de datos.

En Tinker:

use App\Models\Curso
$curso = new Curso; // aquí estamos instanciando el objeto 
// dentro de una variable llamada curso
$curso->name ="nombre del curso"; // asignamos un valor 
// a la propiedad name
// que es un campo de la tabla
$curso->description="descripción del curso"; // más propiedades
$curso; // esta línea sólo devuelve info del objeto
$curso->save(); // guarda la info del objeto en la tabla

Si después de salvar, volvemos a ejecutar:

$curso;

Tendremos la información de los campos created_at y updated_at leídos directamente desde la base de datos. Si modificáramos el objeto, se actualizaría el campo updated_at.

Para actualizar un campo, como el objeto ya está creado, basta con escribir:

$curso->description="descripción actualizada";
$curso->save();

Podemos así añadir más campos:

$curso2 = new Curso;
$curso2->name ="otro curso"; 
$curso2->description="otra descripción del curso";
$curso2->save();

Recursos

Enlace de Youtube: https://www.youtube.com/watch?v=MUOKdpbgbNk&list=PLZ2ovOgdI-kWWS9aq8mfUDkJRfYib-SvF&index=12

Comentario sobre git: https://es.stackoverflow.com/questions/368437/como-crear-versiones-de-un-proyecto-con-git

Guía breve para git: https://rogerdudler.github.io/git-guide/index.es.html

Laravel: Modificar bases de datos (parte 7)

Archivos/carpetas
  • database/migrations

Diferencia entre migrate:fresh y migrate:refresh

El primero ejecuta uno a uno el método down de cada migración, y luego ejecuta uno a uno el método up.

El segundo borra todas las tablas, y ejecuta uno a uno el método up.

Son métodos destructivos, que eliminarían los registros de la base de datos si los hubiera. Por ello vamos a aprender a modificar las tablas in tener que ejecutar estos métodos

Agregar campos a una tabla

Vamos a añadir un campo a nuestra tabla users.

Para practicar esto, añadimos manualmente un registro, con phpmyadmin, a la tabla users, con nombre, contraseña y email.

Creamos una nueva migración, escrita con una convención para facilitarnos las cosas.

php artisan make:migration add_avatar_to_users_table

add_avatar_to_users_table indica que estamos haciendo una migración de añadir una campo lamado avatar a la tabla users. Esto creará un archivo de migración que contiene las siguientes funciones:

public function up()
    {
        Schema::table('users', function (Blueprint $table) {
            //
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::table('users', function (Blueprint $table) {
            //
        });
    }

La función up llama a la clase Schema con el método table, que incluye la función con el parámetro del tipo Blueprint con nombre table, para que podamos añadir campos a la tabla. En la función down escribiremos lo necesario para revertir los campos.

    public function up()
    {
        Schema::table('users', function (Blueprint $table) {
            $table->string('avatar')->nullable();            
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::table('users', function (Blueprint $table) {
            $table->dropColumn('avatar');
        });
    }

Hemos usado el método nullable para el campo avatar, indicando que éste puede ser null. Ahora podemos ejecutar la migración con php artisan migrate para ver los cambios.

    php artisan migrate

Y vamos a volver a migrar modificando antes el método up de nuestra migración, donde añadimos el método after para colocar el campo donde queremos:

    public function up()
    {
        Schema::table('users', function (Blueprint $table) {
            $table->string('avatar')->nullable()->after('email');            
        });
    }

El campo está al final de la tabla, donde ya hay registros, y tiene el valor null. Revertimos los cambios con un rollback:

    php artisan migrate:rollback

Modificar propiedades de un campo de una tabla

Observamos que el campo name acepta 255 caracteres. Vamos a hacer que sólo acepte 150.

Para este tipo de cambios necesitamos instalar una dependencia, ejecutando este comando en la terminal:

composer require doctrine/dbal

Debemos crear una migración como la que sigue, usando también el nombre por convención:

php artisan make:migration cambiar_propiedades_to_users_table

Ya tenemos nuestro nuevo archivo de migración que, como en el ejercicio anterior, está nombrado por convención para facilitar la escrituradel código.

El siguiente comando ejecuta el método up de cada una de las migraciones, así crearemos las tablas. Desde la consola, migramos. recordamos que para migrar tenemos que ejecutar este comando:

php artisan migrate

El método down eliminará la tabla cuando ejecutemos ciertos comandos de artisan. Modificamos las funciones up y down como sigue, creo que el código se explica solo: estamos usando el método change para cambiar el número de caracteres del campo name de la tabla users, y poniéndolo como estaba en la función down usando el mismo método:

    public function up()
    {
        Schema::table('users', function (Blueprint $table) {
            $table->string('name', 150)->change();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::table('users', function (Blueprint $table) {
            $table->string('name', 255)->change();
        });
    }

Podemos ejecutar la migración y comprobar los cambios con phpmyadmin. En ningún momento estamos perdiendo datos de la tabla.

Seguimos practicando: añadamos un poco más de código, para hacer que name acepte campos nulos:

    public function up()
    {
        Schema::table('users', function (Blueprint $table) {
            $table->string('name', 150)->nullable()->change();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::table('users', function (Blueprint $table) {
            $table->string('name', 255)->nullable('false')->change();
        });
    }

Hemos añadido la opción de que el campo name pueda contener valores nulos. para hacer efectivo este nuevo cambio, debemos hacer un rollback y migrar de nuevo.

Recursos

Enlace de Youtube: https://www.youtube.com/watch?v=2pppMAtIlro&list=PLZ2ovOgdI-kWWS9aq8mfUDkJRfYib-SvF&index=11

Laravel: bases de datos (parte 6)

Carpetas de esta lección
  • config/database.php
  • .env
  • database/migrations

Creamos base de datos con phpmyadmin

Creamos una base de datos desde phpmyadmin y la llamamos blog, el mismo nombre que nuestro proyecto.

Abrimos el archivo config/database.php.

Ahí está definida el tipo de base de datos con la que nos conectamos, así como otras variables por defecto. El tipo de base de datos está en esta línea:

    'default' => env('DB_CONNECTION', 'mysql'),

Más abajo debemos indicar el host, la base de datos, el usuario, la contraseña. Podemos hacerlo ahí directamente, pero es mejor no hacerlo porque al subirlo a Github quedaría expuesto. Por eso es recomendado hacerlo en el archivo .env, como indica el mismo archivo. Nos podemos quedar con los valores por defecto para este ejercicio, que son los valores que adjudica XAMPP.

Creación de tablas, migraciones

Podemos crear las tablas desde phpmyadmin, mas lo vamos a hacer usando las herramientas de Laravel.

Las migraciones son el control de versiones de la base de datos, así como su estructura. Echemos un vistazo a la migración de database/migrations llamado create_users. Vemos dos funciones públicas, up y down, y nos detendremos en la función up que nos va a crear nuestra tabla con sus columnas:

public function up()
    {
        Schema::create('users', function (Blueprint $table) {
            $table->id();
            $table->string('name');
            $table->string('email')->unique();
            $table->timestamp('email_verified_at')->nullable();
            $table->string('password');
            $table->rememberToken();
            $table->timestamps();
        });
    }

La función up llamará a la clase Schema con el método create, con dos parámetros: el nombre de la tabla y una función que recibe como parámetro el objeto de tipo Blueprint llamado $table, y ese objeto llama´ra sucesivamente a varios métodos. Cada uno de ellos tiene unas propiedades muy concretas que las asignará a cada tabla. por ejemplo, el solo hecho de llamar al método id() hará que se cree un campo id que tendrá la propiedad autoincrement, del tipo entero y sin signo.

No nos detendremos de momento a analizar cada uno de los métodos que nos proporciona Laravel para los campos de la tabla, con muchas propiedades distintas y con su utilidad. En la documentación de Laravel tendremos todas las propiedades de las columnas y los métodos.

El siguiente comando ejecuta el método up de cada una de las migraciones, así crearemos las tablas. Desde la consola:

php artisan migrate

El método down eliminará la tabla cuando ejecutemos ciertos comandos de artisan.

Más sobre migraciones

En nuestras base de datos se ha creado una tabla adicional, donde se registran cada una de las migraciones, la tabla migrations. Cada vez que creemos y hagamos nuevas migraciones, se grabará un registro en esta tabla.

Para crear nuestras migraciones, tenemos el siguiente comando:

php artisan make:migration cursos

Así crearemos una nueva migración, con el nombre «cursos». Este comando creará un archivo php con toda la estructura de una migración, incluyendo los métodos up y down (por ahora vacíos) para nuestra migración. En ella podemos crear una tabla o modificar alguna tabla existente.

En el método up, llamamos a la clase Schema, con el método create, que recibe dos parámetros, el nombre de la tabla y una función anónima, que a su vez recibirá un parámetro que es un objeto de tipo Blueprint, instanciado con la variable $table:

public function up()
    {
        Schema::create('cursos', function(Blueprint $table){
            //métodos
        })
    }

Ahora tenemos que llamar a varios de sus métodos, para crear los campos de la tabla. Aquí llamaremos al método id() y al método timestamps() (para crear las tablas created_at y update_at):

    public function up()
    {
        Schema::create('cursos', function(Blueprint $table){
            $table->id();
            $table->timestamps();
        })
    }

Creamos dos columnas más, una para el nombre del curso y otra para la descripción. El campo del nombre puede ser del tipo varchar, así que usamos el método string(), para un campo de máximo 255 caracteres. Necesitamos que el campo de la descripción almacene más de 255 caracteres, por lo que usamos el método text(). A estos dos métodos le pasamos también el nombre de la tabla como parámetro.

    public function up()
    {
        Schema::create('cursos', function(Blueprint $table){
            $table->id(); 
            $table->string('name'); 
            $table->text('description'); 
            $table->timestamps(); 
        });
    }

No podemos olvidar el método down, donde borraremos la tabla en la migración. Para ello usamos de nuevo la clase Schema con el método dropIfExist:

    public function down()
    {
        Schema::dropIfExists('cursos');
    }

Si ejecutamos de nuevo el comando de artisan php artisan migrate podremos crear la nueva tabla. En consola obtendremos esta respuesta:

Migrating: 2022_07_03_102823_cursos
Migrated:  2022_07_03_102823_cursos (47.42ms)

Ojo con la tabla migrations, pues se ha añadido un registro con el campo batch (lote) con el valor 2, el segundo lote de nuestras migraciones. Para eliminar este registro, tenemos que «ir un paso atrás».

Para revertir la última migración, usamos el siguiente comando, rollback. El registro de migrations al que hemos hecho mención se eliminará, y también se ejecutará el método down de la última migración, es decir, se eliminará la nueva tabla.:

php artisan migrate:rollback

De hecho, si volvemos a ejecutar el comando se eliminarán por completo todas las tablas, pues están creadas en el lote 1. Basta con volver a ejecutar php artisan migrate para crear, en esta ocasión, todas a la vez.

En este punto, nos interesa dejar la base de datos vacía, luego eliminar manualmente el archivo de la migración de cursos, y luego migrar de nuevo, pues vamos a crear la tabla cursos de otra forma:

php artisan make:migration create_cursos_table

Si seguimos esta convención, crearemos una migración como anteriormente, con la tabla cursos… pero en esta ocasión Laravel ya incluye los campos id, created at y updated at, y ya rellena el método down:

    public function up()
    {
        Schema::create('cusos', function (Blueprint $table) {
            $table->id();
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('cusos');
    }

Ahora sólo nos quedaría añadir manualmente los campos nombre y descripción para nuestra tabla y volver a hacer la migración.

Explicaremos el siguiente comando:

   php artisan migrate:fresh

Ejecuta el método down de cada una de las migraciones, seguido del método up. Es decir, elimina todas la tablas y las vuelve a crear. No es recomendable cuando el proyecto está en producción, porque al eliminar todas las tablas eliminaría también los registros de las mismas. Por eso, si quisiéramos añadir o quitar campos de una tabla o cambiar propiedades de los campos, tenemos otras posibilidades.

Recursos

Enlace de Youtube: https://www.youtube.com/watch?v=C91FOKq7v-k&list=PLZ2ovOgdI-kWWS9aq8mfUDkJRfYib-SvF&index=9

Laravel: vistas y plantillas (parte 5)

Carpetas de esta lección
  • resources/views
  • Http/Controllers
  • resources/views/layout

Primera parte: uso de vistas

Para mostrar código HTML, debemos crear unos documentos llamados vistas. Hasta ahora estamos devolviendo sólo frases.

Vamos a resources/views y creamos un archivo llamado home.php. También crearemos una carpeta dentro llamada «cursos» donde estarán las vistas de cada una de las URL de los cursos, que son 3. Por convención, al archivo de cada vista lo nombraremos igual que a cada método invocado en las rutas.

Atajo de teclado: dentro de cada uno de estos archivos php escribimos en Visual Studio Code un signo de exclamación y pulsamos enter, para que se autocomplete con todo el código HTML básico para un archivo con Doctype HTML y los tags mínimos imprescindibles para un archivo de este tipo (html, head title y body).

Vamos al archivo HomeController, y tomamos la frase que devolvemos dentro del método para pegarla dentro de un tag h1 dentro del body de home.php. Luego, escribimos el método view dentro del invoke de HomeController. No es necesario especificar que el archivo que estamos lamando es un archivo php. Queda la clase así:

class HomeController extends Controller
{
    public function __invoke(){
        return view("home");
    }
}

Y el archivo home.php así:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <h1>Bienvenido a la página principal</h1>
</body>
</html>

Hacemos esto mismo para CursoController, modificando también cada una de las vistas (añadiendo las frases dentro de h1 como en el caso de home.php), y dejamos su código así:

class CursoController extends Controller
{
    public function index(){
        return view("curso.index");
    }

    public function create(){
        return view("curso.index");
    }

    public function show($curso){
        return view("curso.show");
    }
}

Lo primero, notamos que ahora estamos especificando la ruta de cada vista, mediante un punto: curso.index, curso.create y curso.show.

Las dos primeras vistas están perfectas, pero debemos hacer algo con la variable $curso del método show(). No basta con escribir la variable dentro de la vista show como sigue:

(...)
<body>
    <h1>Url con la variable <?php echo $curso?></h1>
</body>
(...)

Porque Laravel nos arrojaría un error diciendo que la variable no está definida dentro del método. Definimos la variable dentro de un array (entre corchetes:

 public function show($curso){
        return view("cursos.show", ['curso' => $curso]);
    }

Si le pusiéramos otro nombre a la variable, como por ejemplo «alfa», la rescataríamos dentro de la vista con ese nombre:

 public function show($curso){
        return view("cursos.show", ['alfa' => $curso]);
    }

Cuando tenemos intención de pasarle una variable a la vista que coincide con el nombre que estoy recibiendo podemos usar compact() así:

    public function show($curso){
        // return view("cursos.show", ['curso' => $curso]);
        return view("cursos.show", compact("curso"));
    }

Plantillas

Vamos a reciclar todo el código HTML que se repite dentro de cada vista usando plantillas con el motor blade. Primero, vamos a una de las vistas y añadimos algunos comentarios que se reemplazarían por código HTML que también se usaría en otras vistas:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Home</title>
    <!-- favicon -->
    <!-- estilos -->
</head>
<body>
    <!-- header -->
    <!-- nav -->
    <h1>Bienvenido a la página principal</h1>
    <!-- footer -->
    <!-- script -->
</body>
</html>

Atajo de teclado de Visual Studio Code: si escribimos una línea, la seleccionamos y pulsamo [CTRL] + K, después pulsamos [CTRL] + C para comentar y [CTRL] + U para descomentar.

Creamos la carpeta layout dentro de views, y dentro el archivo plantilla.blade.php. La extensión blade.php es necesaria. Para el contenido que queremos que varíe dentro de cada platilla, usaremos @yield(«nombre identificativo del contenido»). La plantilla queda así:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>@yield('title')</title>
    <!-- favicon -->
    <!-- estilos -->
</head>
<body>
    <!-- header -->
    <!-- nav -->
    @yield('content')
    <!-- footer -->
    <!-- script -->
</body>
</html>

Vamos con la vista home.php. En primer lugar, renombramos el archivo como home.blade.php. Luego añadimos un @extends al comienzo de la vista para hacer referencia a la plantilla. Además, usaremos @section para especificar el contenido que cambia dentro de cada vista. Usaremos @section de dos formas, una con una sola línea de código y otra que permite varias líneas de código. La vista home.blade.php queda de la siguiente manera:

@extends('layouts.plantilla')

@section('title', 'Home')

@section('content')
    <h1>Bienvenido a la página principal</h1>
@endsection

Inspeccionando el HTML de esta página vemos que el title es «Home» yq ue el contenido está dentro del body, a su vez dentro de un h1, como especificamos en el @section.

Antes de continuar con todas las vistas, podemos instalar la extensión Laravel Blade Snippets para colorear el có´digo de blade y además autocompletarlo.

Hacemos lo propio con cada una de las vistas, pasando el título y el contenido de cada una con @section, luego de extender la plantilla. También renombramos cada archivo con la extensión blade.php. Ojo con la vista que contiene una variable, show.blade.php, cuya sección content quedaría mejor así, con la doble llave para pasar la variable (nótese también la doble llave para comentar código):

@extends('layouts.plantilla')
@extends('layouts.plantilla')

@section('title', 'Página con variable')

@section('content')
    {{-- <h1>Url con la variable <?php echo $curso?></h1> --}}
    <h1>Url con la variable {{$curso}}</h1>
@endsection

Recursos

Enlace de Youtube: https://www.youtube.com/watch?v=KZGHCSIb9Q0&list=PLZ2ovOgdI-kWWS9aq8mfUDkJRfYib-SvF&index=6

Laravel: grupos de ruta (parte 4)

Podemos agrupar las rutas que hemos creado, ya que las tres usan el mismo controlador., Para ello, usaremos el método group().

Cambiaremos este código:

Route::get('/', HomeController::class);

Route::get('cursos', [CursoController::class, 'index']);
Route::get('cursos/create', [CursoController::class, 'create']);
Route::get('cursos/{curso}', [CursoController::class, 'show']);

Por este otro:

Route::get('/', HomeController::class);

Route::controller(CursoController::class)->group(function(){
    Route::get('cursos','index');
    Route::get('cursos/create','create');
    Route::get('cursos/{curso}','show');
});

Así el código queda mucho más limpio. Esta es una característica de Laravel 9.


Recursos

Enlace de Youtube: https://www.youtube.com/watch?v=srDHQLqbwwk&list=PLZ2ovOgdI-kWWS9aq8mfUDkJRfYib-SvF&index=5

Laravel: Controladores (parte 3)

En esta lección aprenderemos a usar y crear controladores. Sacaremos la lógica del archivo app.php y dejaremos escrito varios fragmentos de código según la convención de nombres de variables y métodos, creando controladores para tal fin. Es muy importante conocer la convención de la nomenclatura.

Archivos que vamos a investigar en esta lección
  • routes/web.php
  • app/Http/Controllers
Consideraciones
  • Los controladores en versiones anteriores se llaman de otra forma
  • Hemos instalado otra extensión de Visual Studio Code, llamada php Intelephense, que autocompleta nombres de controladores y resalta errores en el código (entre otras cosas)
Crear controladores

Un controlador será un archivo php que tenemos que crearlo en la carpeta app/Http/Controllers. Podemos crearlo manualmente, y también desde la terminal.

php artisan make: controller HomeController

Desde la terminal de Git Bash, navegaremos hasta la carpeta del proyecto y escribiremos el siguiente código para crear un controlador de nombre HomeController. Los nombres se escriben así por convención. Al hacerlo así, desde la terminal y con Artisan, se nos escribe el código que necesitamos para empezar.

php artisan make: controller HomeController

El archivo empieza con el namespace, y nos centraremos en la clase HomeController que se ha creado, donde escribiremos el método.

Usar controladores

En el archivo web.php escribiremos la línea que se refiere al controlador que vamos a usar:

use App\Http\Controllers\HomeController;

Nuestra ruta para la home ahora debe quedarse así, sustituyendo la función por el uso del controlador:

Route::get('/', HomeController::class);

Y el controlador HomeController:

class HomeController extends Controller
{
    public function __invoke(){
        return "Bienvenido a mi proyecto de Laravel";
    }
}

Ya podemos visitar la home con el navegador y ver el mensaje «Bienvenido a mi proyecto de Laravel». Nótese que hemos nombrado a la función __invoke. Esto se escribe así por convención, tanto el hecho de que comience con dos guiones como el nombre del método.

Resumen de lo anterior
  • Creamos el controlador vacío con la consola usando el comando de artisan, respetando la convención de los nombres.
  • En routes/web.php, llamamos al controlador con use
  • Quitamos la función de la ruta de la home y llamamos al controlador usando el método class
  • En el archivo HomeController creado, escribimos el mensaje de bienvenida dentro de la clase del controlador con una función pública llamada __invoke(). Si no se especifica ningún nombre de método, el método de la calse será el método __invoke (lo tenemos en cuenta como concepto para la continuación).
Seguimos creando controladores

Mirando atentamente el siguiente código de web.php, vemos que todos tienen que ver que la URL comienza con la palabra «cursos». Para ello crearemos un único controlador para administrar el código que se muestra más abajo. Comentaremos todas las rutas y nos quedaremos con estas:

Route::get('cursos', function () {
    return "Bienvenido a la página de cursos";
});

Route::get('cursos/create', function () {
    return "Inserción de formulario";
});

Route::get('cursos/{curso}', function ($curso) {
    return "Url con la variable $curso";
});

Podemos crear el controlador desde la terminal de Visual Studio Code, con el comando que hemos usado antes. Ahora nombraremos nuestro controlador como CursoController, en singular por convención, y usando las mayúsculas como hemos hecho antes:

php artisan make:controller CursoController

Usaremos los siguientes nombres de los métodos: index, create y show. El método __invoke se usa solamente para una única ruta, en este caso tenemos tres. Como cada una de ellas está destinada a mostrar una cosa en particular (un índice, un formulario y algo de contenido) usamos estos tres nombres. Son nombres usados (de nuevo) por convención, aunque podríamos usar los que queramos. Nuestra clase «vacía» estará de la siguiente manera:

class CursoController extends Controller
{
    public function index(){

    }

    public function create(){

    }

    public function show(){

    }
}

Pondremos dentro de cada método cada uno de los mensajes que nos retornaba cada ruta. Como vemos en el código, la variable $curso está ahora dentro del método $show:

class CursoController extends Controller
{
    public function index(){
        return "Bienvenido a la página de cursos";
    }

    public function create(){
        return "Inserción de formulario";
    }

    public function show($curso){
        return "Url con la variable $curso";
    }
}

Y ya en web.php para usar el método con nuestras rutas:

use App\Http\Controllers\CursoController;

Para llamar a cada uno de los métodos de CursoController (index, create y show) no podemos llamar sólo al controlador, pues esto buscaría el método __invoke (y este controlador no tiene tal método). Así que le pasaremos en un array, entre corchetes, el nombre del controlador con ::class y el nombre de cada método entre comillas, y las rutas quedarían como sigue:

Route::get('/', HomeController::class);

Route::get('cursos', [CursoController::class, 'index']);

Route::get('cursos/create', [CursoController::class, 'create']);

Route::get('cursos/{curso}', [CursoController::class, 'show']);
Resumen
  • Hemos creado otro controlador, esta vez con tres funciones, cuyos nombres se usar así por convención, según lo que hace cada uno
  • Podemos crear controladores también desde la terminal de Visual Studio Code
  • A la hora de usar el controlador desde el archivo de rutas, lo hemos llamado tres veces (uno por cada ruta) usando un array para llamar a cada uno de sus métodos.

Recursos

Enlace de Youtube: https://www.youtube.com/watch?v=0YxgCH2R2bE&list=PLZ2ovOgdI-kWWS9aq8mfUDkJRfYib-SvF&index=4

Laravel: Rutas (parte 2)

Archivos que vamos a investigar en esta lección
  • routes/web.php

Con Laravel no vamos a crear un archivo php por cada página de nuestra web, sino que vamos a usar el FrontController, el patrón en el que se basa Laravel.

Tendremos sólo un archivo de entrada en nuestra aplicación, el index.php. Los archivos a los que el usuario puede acceder están en la carpeta public. Esto se hace por motivos de seguridad, para que no pueda acceder a otros más sensibles.

Laravel sabe qué información debe mostrar cuando un usuario escribe una URL. El archivo que se encarga de administrar las rutas está en la carpeta routes y se llama web.php.

Vemos el contenido de este archivo: aquí Laravel devuelve la vista welcome cuando el usuario pide la ruta principal, que sería localhost/blog/public, por eso en el primer parámetro de gert se indica simplemente un slash:

Route::get('/', function () {
    return view('welcome');
});

Si cambiamos el fragmento anterior por el que sigue, obtendremos sólo la frase al visitar la URL:

Route::get('/', function () {
    /*return view('welcome');*/
return "Bienvenido a mi proyecto de Laravel";
});

Si añadimos un fragmento como el que sigue, estaremos añadiendo una ruta para la URL «cursos» que mostrará el contenido «Bienvenido a la página de cursos». Usamos de nuevo Route::get() con parámetros personalizados. Para ver este contenido, accederemos a la ruta localhost/blog/public/cursos:

 Route::get('cursos', function () {
    return "Bienvenido a la página de cursos";
});

Dejamos esta ruta también para utilizarla en la lección siguiente:

Route::get('cursos/create', function () {
    return "Inserción de formulario";
});

Introduzcamos variables para «subrutas»: basta con utilizar de nuevo Route::get() añadiendo una variable la la función (nótese que en el primer parámetro de get la variable se encuentra entre corchetes):

Route::get('cursos/{curso}', function ($curso) {
    return "Url con la variable $curso";
});

Para probar esta nueva función, visitemos las siguientes direcciones:

  • http://localhost/blog/public/cursos/personalizada
  • http://localhost/blog/public/cursos/variable
  • http://localhost/blog/public/cursos/con una variable
  • http://localhost/blog/public/cursos/que me apetece

En este punto deberíamos instalar Laravel Snippets, la extensión de Visual Studio Code para hacer esta tarea repetitiva más rápidamente (se indica aproximadamente en el minuto 8 del vídeo).

Prestemos atención un momento a este fragmento para crear una ruta, donde vamos a pasar más de una variable para una ruta:

Route::get('nuevaruta/{subruta}/{otrasubruta}', function($subruta, $otrasubruta) {
    return "Estamos en la ruta $subruta y en la subruta $otrasubruta";
});

Los dos últimos fragmentos de código son bastante parecidos. Nuestro código podría interpretar la «otrasubruta» como una variable opcional, y así lo vamos a expresar:

Route::get('nuevaruta/{subruta}/{otrasubruta?}', function($subruta, $otrasubruta = null) {
    if ($otrasubruta) {
        return "Estamos en la ruta $subruta y en la subruta $otrasubruta";
    }
    else {
        return "Estamos en la ruta $subruta";
    }
});
  • Una de las dos variables de get tiene un signo de interrogación al final, indicando que la variable es opcional: la variable $otrasubruta.
  • Ésta ha sido inicializada en la función con valor null
  • Luego, hemos escrito un condicional que comprueba si la variable ha sido o no inicializada, y muestra un mensaje distinto según cada caso.

De esta forma podemos acceder a localhost/blog/public/nuevaruta/algo y también a localhost/blog/public/nuevaruta/algo/otracosa. O también, por ejemplo, a localhost/blog/public/nuevaruta/categoria y también a localhost/blog/public/nuevaruta/categoria/subcategoria.

Este condicional debería estar en un controlador, ya que este fragmento pertenece a la lógica de nuestra aplicación. Lo veremos en la siguiente lección.


Recursos

Enlace de Youtube: https://www.youtube.com/watch?v=PDbOsGlCf7o&list=PLZ2ovOgdI-kWWS9aq8mfUDkJRfYib-SvF&index=3

Enlace sobre la arquitectura de Laravel: https://www.oulub.com/es-ES/Laravel/structure#introduction

Laravel: instalaciones previas (parte 1)

Herramientas necesarias
  • XAMPP – algunos conocimientos sobre este programa pueden venir muy bien
  • Visual Studio Code – editor de código con el que haremos este «curso»
  • Git bash – consola de comandos para este curso – se puede hacer con la que tiene Windows por defecto, pero nos viene bien seguir ampliando las herramientas. Además de que ésta nos permite enlazar con nuestra cuenta en Github.
  • Composer: se puede descargar un instalador desde su página, y tambiéhn nos proporcionan líneas de comando para su instalación: https://getcomposer.org/download/

Para instalar Laravel con Composer, simplemente ejecutamos el comando «composer global require laravel/installer» en la terminal Git bash desde la carpeta htdocs de XAMPP (antes debemos dirigirnos a esta carpeta). Los archivos se descargan desde el repositorio.

composer global require laravel/installer

Nuestra instalación de XAMPP viene con php 8.1, con lo que no necesitamos cambiar la versión de php para que se instale la versión de Laravel correcta.

En esta lección hemos aprendido el comando para crear el nuevo proyecto en Laravel: como ya hemos navegado a la carpeta htdocs desde la terminal de Git, sólo ejecutamos el comando.

laravel new blog

Desde la URL http://localhost/blog/public/ podemos ver el nuevo proyecto sin modificar. Al pie de esta página inicial ya leemos la versión de Laravel y la versión de PHP que estamos usando (Laravel v9.14.1 (PHP v8.1.6)).

Abriendo Con Visual Studio Code la carpeta blog de nuestro proyecto, podemos editar el HTML de la página de bienvenida. Se encuentra en la ruta htdocs\blog\resources\views\welcome.blade.php.


Recursos

Enlace de Youtube: https://www.youtube.com/watch?v=A-BL8Ir7puE&list=PLZ2ovOgdI-kWWS9aq8mfUDkJRfYib-SvF&index=2

Una documentación sobre Laravel 5: https://richos.gitbooks.io/laravel-5/content/

Enlace sobre la arquitectura de Laravel: https://www.oulub.com/es-ES/Laravel/structure#introduction

Configurar BuddyPress

Logotipo de Wordpress

Instalamos y configurar BuddyPress en uno de nuestros subsitios con subdominio de Likone.es que usamos para pruebas, para posteriormente instalarlo de manera definitiva en un sitio con dominio propio.  

  1. Seleccionar los componentes
  2. Crear y asignar páginas

Paso 1 – Componentes

Habilitar el registro de usuarios a través de Settings > General > Allow, para que cualquier persona pueda registrarse en el sitio.


Paso 2 – Configurar Páginas

El próximo paso será configurar las páginas que usará BuddyPress. La mayoría de las páginas ya están creadas.

Pero nosotros sólo queremos BuddyPress en un subsitio, así que seguimos estos pasos de la página oficial del plugin

https://codex.buddypress.org/getting-started/installation-in-wordpress-multisite/#d-activate-buddypress-only-in-one-of-the-secondary-sites-of-the-network

La siguiente información está extraída directamente del enlace anterior:

Activate BuddyPress in only one of the Secondary Sites of the Network

  1. Go to Dashboard → Network Admin.
  2. Click on Sites link.
  3. Find the ID number of the site you want to be the root site of your BuddyPress installation.
  4. Open up your installation’s wp-config.php file.
  5. Adddefine ( 'BP_ROOT_BLOG', $blog_id );to your wp-config.php file where $blog_id is the ID number of your chosen site and save the file.
  6. Go to Dashboard → Network Admin.
  7. Add BuddyPress through Plugins → Add New.
  8. Navigate to the subsite which you identified in your wp-config.php file earlier
  9. Activate BuddyPress. You will be redirected to the BuddyPress Welcome screen.
  10. Configure BuddyPress.

Guía para la instalación de un nuevo sitio de WordPress en Likonet.es

He creado esta entrada como breve guía para seguir a la hora de crear un sitio nuevo de WordPress en Likonet.es de WordPress. Estas acciones están orientadas a añadir un sitio nuevo con dominio propio, aunque nuestro multisitio está basado en subdominios.

  • Adquirir un dominio y añadirle las DNS de nuestro hosting
  • Crear la base de datos del sitio con su usuario y contraseña, otorgándole los privilegios sobre la misma
  • Espera 24 horas a que se propaguen las DNS
  • Subir el archivo .zip de la instalación de WordPress a la carpeta del sitio y descomprimirlo
  • Instalar WordPress de la manera usual

Configuración de WordPress en Likonet.es con SiteOrigin

Ya tendremos nuestro dominio apuntado a nuestras DNS y los archivos preparados para empezar a instalar un nuevo sitio de WordPress en Likonet. Con esto sería más que suficiente para empezar, pero añadiré unos pasos más que servirán para comenzar a dar diseño al nuevo sitio con los plugins que estamos usando últimamente.

Usamos el plugin SiteOrigin para personalizarlo:

  • Instalar los plugins que usaremos para la personalización: SiteOrigin Page Builder y Site Origin Widget Bundle
  • Crear una página nueva, desde el editor de Site Origin (ver imagen al final de la lista)
  • Usualmente, eligir un «diseño preinstalado»
  • Ir a Apariencia > Personalizar, y en «Ajustes de la página de Inicio» elegir la página que hemos creado como página de inicio
  • Añadir algo de CSS elementos de la cabecera y algunos márgenes, desde Apariencia > Temas > Personalizar (el tema que esté activo) > CSS adicional

Añado algunas capturas del proceso que pueden servir de orientación.

Crear página desde editor de Site Origin
Diseño pre-instalado de Site Origin
Para editar bloques de Site Origin

Crear un sitio con subdominio en Likonet.es

Para crear un sitio con el dominio midominio.likones.es, tenemos que seguir una serie de pasos distinta, ya que la instalación es la de Likonet.es, no es necesaria una nueva base de datos ni subir archivos al servidor. Lo que sí es necesario en configurar el nuevo dominio en CPanel.

  • Ir a Cpanel > Subdominios
  • Configuramos el subdominio de la siguiente manera: nombre del subdominio: el que elijamos, dominio principal: Likonet.es, y carpeta de destino public_html.

Configuraremos el dominio nuevo desde la instalación de multisitio de Likonet.es

  • Añadimos el nuevo sitio desade Administrador de la red > Sitios > Añadir nuevo
  • En la dirección de URL escribimos el nombre del subdominio
  • Rellenamos todos los campos obligatorios.

Subsitio con dominio propio

Siguiendo las recomendaciones de la entrada de más abajo, podemos crear un sitio con subdominio y luego adjudicarle un dominio propio. Esto puede ser uy útil para ahorrar espacio en el hosting.

https://wetopi.com/es/wordpress-multisite-con-diferentes-dominios/

Lo siguiente está extraído del enlace anterior:

¡SÍ, Multisitio con Subdominios! – el mapeo de dominios funciona con el mismo modo de subdominios de WordPress – Antes de WordPress 4.5, la asignación de dominios requería de un plugin para gestionar la asignación de dominios.

Aunque te parezca extraño, tendrás que asignar al sitio un subdominio temporal. Luego WordPress ya te dará la opción de reemplazarlo por dominio completo.

Una vez añadido el Nuevo sitio, con su «Dirección URL» temporal – el subdominio – vuelve a editarlo (puedes hacerlo desde el listado de Sitios).

Es necesario hacer un ajuste en el archivo wp_config.php: del multisitio para que se pueda visitar el Escritorio con normalidad, porque el dominio de las cookies tiene que estar definido. Para ello, añadimos esta línea:

define('COOKIE_DOMAIN', $_SERVER['HTTP_HOST'] );