Personalizar el Auth, para autenticarse con el username, en Laravel

logo laravel

Personalizar el auth, para autenticarse con el username en Laravel, puede sernos oportuno, si necesitamos un comportamiento mas estricto del modo de acceso a nuestra aplicación.

Los cambios necesarios, incluyen  modificar todo lo relacionado con el Login, o sea  la Migración, el Modelo, el Controlador y la Vista.

El controlador encargado del login es Login Controller( App\Http\Controllers\Auth\LoginController).

Es el encargado de implementar  el trait AuthenticatesUsers  encargado de la validación del  que se ejecuta al loguearse.

Como el método validateLogin() valida el campo email por defecto, partiendo del  del método username() que retorna automáticamente el campo email, hay que cambiar algunos cosas para modificar este proceso y que nos devuelva el campo username.

Lo primero es en  la migración de la tabla users (2014_10_12_000000_create_users_table.php) agregar el campo username, con el tipo unique.

Schema::create('users', function (Blueprint $table) {
    $table->increments('id');
    $table->string('username')->unique();
    $table->string('name');
    $table->string('email')->unique();
    $table->string('password');
    $table->rememberToken();
    $table->timestamps();
});

Lo segundo es declarar lógicamente este campo como un campo fillable, agregándolo en el modelo(App/User)

protected $fillable = [
    'username', 'name', 'email', 'password',
];

Igualmente como tercer paso, necesitamos agregar el metodo username() en el controlador App\Http\Controllers\Auth\LoginController, para que nos retorne el valor username que necesitamos.

public function username()
{
    return 'username';
}

Por último en la vista, debemos hacer los cambios para modificar el formulario del login.

Aquí es preciso sustituir el campo de tipo email, por un campo de tipo text, y cambiarle valor de la etiqueta name.

<div class="form-group row">
    <label for="username" class="col-sm-4 col-form-label text-md-right">{{ __('Username') }}</label>

    <div class="col-md-6">
        <input id="email" type="text" class="form-control{{ $errors->has('username') ? ' is-invalid' : '' }}" name="username" value="{{ old('username') }}" required autofocus>

        @if ($errors->has('username'))
            <span class="invalid-feedback">
                <strong>{{ $errors->first('username') }}</strong>
            </span>
        @endif
    </div>
</div>

Y esto es todo

Espero sinceramente, que esto sirviera de ayuda a alguien

El elefante no necesita decirle a nadie cuan grande es, le basta con caminar.

NS

Error HY000/1045: Acceso denegado para el usuario ‘root’ @ ‘localhost’ (usando la contraseña: NO)

error php

Si has recibido el error mysqli_real_connect (): (HY000/1045): Acceso denegado para el usuario ‘root’ @ ‘localhost’ (usando la contraseña: NO) phpMyAdmin intentó conectarse al servidor MySQL y el servidor rechazó la conexión…; aquí intento explicarte como resolverlo.

Tanto para usuarios de Xampp como Lamp, el problema radica en que se esta intentando una conexión a SQL con un usuario que no existe.

Veamos el error:

En el archivo config-db.php, que encontrarás en esta ruta ( /etc/phpmyadmin/config-db.php) existen 2 variables: $ dbuser y $ dbpass, que indican los parámetros de conexión de MySQL.

En el mismo archivo existen otros parámetros importantes que podemos modificar como la dirección del servidor ($ dbserver), el puerto ($ dbport), y otros  que pueden ser de utilidad alterar, ante problemas de conexión.

La solución por tanto, es modificar el config-db.php y configurar su contraseña, con la contraseña que le dio al usuario root , o si no tiene una contraseña, dejarla vacía de este modo ''.

Vaya al archivo config.inc.php y busque – $ cfg ['Servidores'] [$ i] ['auth_type']

Cambie el valor de $ cfg ['Servers'] [$ i] ['auth_type'] a ‘cookie’ o ‘http’.

$cfg['Servers'][$i]['auth_type'] = 'HTTP';

Nota- si elige el tipo de autenticación como cookie, cada vez que cierre el navegador y lo vuelva a abrir, deberá iniciar sesión nuevamente.

Cambie el valor de  $ cfg [‘Servers’] [$ i] [‘password’] a vacio »

$cfg['Servers'][$i]['password'] = ''; <-tu contraseña 

En  $ cfg [‘Servidores’] [$ i] [‘AllowNoPassword’] y cambie su valor a verdadero.

$cfg['Servers'][$i]['AllowNoPassword'] = 'TRUE'; 

Tambien podemos hacerlo desde las funciones para usuario avanzado

/* User for advanced features */
$cfg['Servers'][$i]['controluser'] = 'tu usuario';
$cfg['Servers'][$i]['controlpass'] = 'tu contraseña'; /* '' para dejar vacio */

En total oscuridad, cualquier cosa puede ser luz

Y

Ver el tiempo de carga de nuestra página Prestashop

logo prestashop

Entre las muchas cosas que se pueden hacer utilizando el modo DEBUG, podemos ver el tiempo de carga de nuestra página Prestashop.

Puedes ver acá como activar o desactivar el método DEBUG.

Para ver en el Backend el tiempo de carga, debemos activar la opción ‘_PS_DEBUG_PROFILING_’

Esta  muestra en detalle el rendimiento de nuestra tienda.

Para acceder a ellos debemos seguir la ruta: directorio/config/defines.inc.php”, siendo directorio, aquel donde se ha instalado tienda.

Una vez dentro cambiamos la linea

define(‘_PS_DEBUG_PROFILING_’, false);

por

define(‘_PS_DEBUG_PROFILING_’, true);

Una vez guardado, actualizamos la pagina y ahora podemos ver los tiempos de carga, los tiempos en que se ejecutan las consultas y más información de valor sobre el comportamiento de la web.

Subir montañas, hermana hombres….

J. Martí

Solucionar “Trying to get property of non-object» en Prestashop

error prestashop

Hola, es muy probable que estes recibiendo el error “Trying to get property of non-object» en tu página Prestashop.

Si tienes un ecommerce con actualización automática de los productos desde la web del  proveedor, este error puede surgir en cualquier momento.

Veamos este error esta diciendo que estas tratando de «tomar una propiedad desde algo que no es un objeto» y eso debe ser revisado.

Recibes este error porque tienes activado el modo debug.

Si tu página se ve y funciona bien, es muy probable que puedas obviar este warning y otros de su tipo.

Por eso, si no quieres sumirte en el código, basta con desactivar el modo DEBUG, de tu pagina para no recibir más el error.

MODO DEBUG ¿que es PRESTASHOP?

El Modo DEBUG en PrestaShop,  es una  variable con la cual se puede activar o desactivar el modo de depuración.

Mediante ella, podemos visualizar todos los  mensajes de depuración y avisos PHP, que están diseñados para que  el desarrollador pueda detectar  errores, que de otro modo no veria.

En este link puedes escribirme si necesitas algún tipo de colaboración Contacto

Desactivar el modo DEBUG

Para desactivar el modo DEBUG, debemos acceder por FTP a nuestra tienda y modificar el archivo “defines.inc.php”.

Su ubicación es “directorio/config/defines.inc.php”.

En este caso directorio es el directorio raíz donde hemos instalado PrestaShop.

La variable “_PS_MODE_DEV_,  es la que que activa el modo DEBUG,  y posee dos valores “TRUE= activado” y “FALSE= desactivado”

Una vez dentro  solo deberemos cambiar la linea:

define(‘_PS_MODE_DEV_’, true);

y cambiar el valor de True a False:

define(‘_PS_MODE_DEV_’, false);

El modo DEBUG, dejara de estar activo y los errores dejaran de llegar.

Sabiendo esto ya puedes activar o desactivar el modo DEBUG a tu voluntad para evaluar errores.

Fue tu amor, más difícil y más fallo, que un contrabando de gallos, pasando al amanecer.

W. Chirino

SQLSTATE[HY000]: General error: 1835 Malformed communication packet

laravel error

El error ‘SQLSTATE[HY000]: General error: 1835 Malformed communication packet’, que suele aparecer si nuestra APP en Laravel, trabaja con Maria DB y no soporta la nueva versión del PHP.

Como es un error de configuración, y las nuevas versiones de PHP, son algo mas dúctiles, con la creación de consultas,  debe bastarnos con modificar nuestro archivo database config, añadiendo esta línea de código:

options => [PDO::ATTR_EMULATE_PREPARES => true]

Ojo, esta solución puede tener inconvenientes, pues lo que estamos haciendo es habilitar el uso de declaraciones preparadas en la caché, lo cual puede no ser siempre conveniente.

Lo que hace esta sentencia es hacer el reemplazo de los parámetros  en la librería PDO, en vez de hacerlo en el servidor y así burla la desactualización, por lo que los errores de sintaxis en el tiempo de preparación de la consulta desaparecen, y se traspasan solo al momento de ejecución.

«Quien va en busca de montañas, no puede detenerse a recoger las piedras del camino»

Creando conexiones dinámicas en Laravel

logo laravel

Para crear conexiones dinámicas en Laravel, que varíen en función de nuestras necesidades, tendremos que modificar los valores de los archivos de configuración, que están dentro de la carpeta config.

Los pasos son :

  • Añadimos al archivo .env  las nuevas referencias de valores de conexión.
  • Creamos un tipo de conexión nueva en el archivo que establece nuestra conexión.
  • Creamos una clase que se seteará dinámicamente  los valores.

El archivo .env

Es el encargado de establecer la estructura básica del comportamiento de Laravel para conexiones entre otras cosas.

Aquí añadiremos el marco de las conexiones a la base de datos y al servidor.

DB_CONNECTION_VAR=server_variable
DB_HOST_VAR=  
DB_HOST_VAR=  
DB_PORT_VAR= 
DB_DATABASE_VAR=   
DB_USERNAME_VAR=
DB_PASSWORD_VAR= 
 
FTP_HOST= 
FTP_PASSWORD=  
FTP_USERNAME= 
FTP_PORT= 

El archivo database.

Como sabemos este archivo establece los términos de conexión a la base de datos,  e inicialmente  toma  valores del archivo .env.

Podemos crear en él, tantas conexiones,  como necesitemos, así que lo que haremos será crear una nueva conexión, dentro de database,  que será nuestro conexión dinámica:

'connections' => […….
 'server_variable' => [ 
 'driver' => 'mysql', 
 'url' => env('DB_DATABASE_URL_VAR',''), 
 'host' => env('DB_HOST_VAR', ''), 
 'port' => env('DB_PORT_VAR', ''), 
 'database' => env('DB_DATABASE_VAR','' ), 
 'username' => env('DB_USERNAME_VAR','' ), 
  'password' => env('DB_PASSWORD_VAR','' ), 
   'unix_socket' => env('DB_SOCKET_VAR', ''), 
     'charset' => 'utf8mb4', 
   'collation' => 'utf8mb4_unicode_ci', 
    'prefix' => '', 
  'strict' => false, 
   'engine' => null, 
    ], 
 …………..] 

Lo que haremos ahora  es crear una clase que modifica los valores del archivo config, para poder acceder a ellos de modo dinámico y variarlos en función del tipo de conexión que queremos establecer.

La clase

 ?php 
 namespace App\Personalizado;
 use Illuminate\Support\Facades\DB;
 use Illuminate\Support\Facades\Storage;
 use Illuminate\Support\Facades\Config;
  
 class Conexion
 {
          
     public function conectar()
     {
       $hora = date("H.i.s");
       $sitio = DB::table('sitios')->where('hora_deseada','=',$hora)->get();
       
     if ($sitio); 
          {
             $sitio = DB::table('sitios')->where('id')->first();
             $driv='msql';
             $puerto_conex=$sitio->port_conex;
             $database_name=$sitio->nombre_bd;
             $user_name=$sitio->usuario_bd;
             $contra_=$sitio->pass_bd;
             $host_con=$sitio->host_conex;
             $user_FTP=$sitio->user_FTP; 
             $pass_FTP=$sitio->pass_FTP; 
             $port_conex=$sitio->port_conex;

Leer: Buenas practicas de programación en Laravel

Establecemos la ruta de los  archivos database y filesystem, dentro del archivo config, utilizando la convención del punto de Laravel, y seteamos los datos dinámicos tomados de la bd.

 Config::set([
  'database.connections.server_variable.driver'=>$driv,
  'database.connections.server_variable.database'=>$database_name,   'database.connections.server_variable.username'=>$user_name,
  'database.connections.server_variable.password'=>$contra,
  'filesystem.disk.ftp.driver'=> 'ftp',
  'filesystem.disk.ftp.host' => $host_con,
  'filesystem.disk.ftp.username' => $user_FTP,
  'filesystem.disk.ftp.password' => $pass_FTP,
  'filesystem.disk.ftp.port' => $puerto_conex,
  
       ]);

 Solo conectaremos por ahora via ftp_connect  

 $driver = ( Config::get('filesystem.disk.ftp.driver'));
     
       $host = ( Config::get('filesystem.disk.ftp.host'));
       
       $username = ( Config::get('filesystem.disk.ftp.username'));
       
       $password = ( Config::get('filesystem.disk.ftp.password'));
       
       $port = ( Config::get('filesystem.disk.ftp.port'));
      
       $conex = [$driver, $host, $username, $password, $port];
  
       $ftp_conn = ftp_connect($host) or die("no conecta ftp");
   
       if ($ftp_conn){
  
         echo "<br>Conectado";
  
       $login =ftp_login($ftp_conn,$username,$password);
       
       ftp_pasv($ftp_conn, TRUE);
  
       if($login)
         {echo "<br>logeado";
  
       $remote='httpdocs/tienda/import/importacion.csv';
       $local='./storage/app/csv/convertidos.csv';
         if (ftp_put($ftp_conn,$remote,$local, FTP_BINARY))
           { echo "<br>Upload";}
         else
           {echo "<br>not upload";}
  
         }
       else
         {echo "fallo login";}
  
       if(ftp_close($ftp_conn))
         {echo "conexion cerrada";};
    
    } 
    
     return $conex;
    
     }  

Y listo, esto es todo.

Espero modestamente que este artículo, sirva de ayuda a alguien.

Gracias.

….un sueño es casi todo  y más que  nada;  más que todo al soñarlo, casi nada después……

Tomar un archivo remoto y guardarlo en nuestro servidor de modo aútomatico

laravel

Si estamos trabajando con LARAVEL, empleando un cliente conectado a proveedores, y necesitamos  desarrollar alguna api que pueda importar un archivo remoto, y guardarlo en nuestro servidor de modo automático  para después trabajar con él, una forma sencilla de hacerlo, seria esta:

$dia = date("m.d.y");
$hora = date("H.i.s");
$filepath = 'http://dirección_remota';  
  //fijamos la hora a la que queremos iniciar el proceso de importacion para que el scheduler la vea 
if ($hora === "13:16")  // hora que deseamos hacer la importacion 
        {  $guardar = Storage::disk('importados')->put($dia.'_'.$hora.'_nuevoarchivo', file_get_contents($filepath));  }  

 Si ahora queremos retornar ese último archivo guardado, podemos dirigirnos a su posición en la carpeta storage, y escoger el último asi:

$archivo = \Storage::disk('importados')->files()->end();

A partir de aquí podríamos, trabajar con la variable archivo.

Y listo, esto es todo.

Espero modestamente que este artículo, sirva de ayuda a alguien.

Gracias.

…..lo que realmente importa no es lo que te da la vida, sino lo que haces con ello….

Crear y almacenar clases

laravel

Laravel trabaja con clases que generalmente se guardan en repositorios desde el cual son llamadas. Esta estructura requiere que ademas de conocer la organización del framework, comprendamos su enfoque para crear y almacenar las clases.

Puede parecer para muchos complicado, pero es una estructura que desde mi punto de vista esta enfocada a componentes como parte de un todo, de ahi la necesidad de entenderla adecuadamente

Crear una clase

Las clases en Laravel se crean dentro de la carpeta App, usando psr-4. Basta con crear un archivo en una dirección dentro de App y comenzaremos a tener una clase reconocida, por la aplicación:

Creamos el archivo Conexión dentro de una carpeta nueva llamada Personalizado

  App/Personalizado/Conexión.php 

Y luego colocamos la clase con sus métodos y/o atributos. En nuestro caso estamos creando una clase que sustituirá los valores de conexión a la bd en el archivo env.

 class Conexion
 {
    public function conectar()
    {
         return 'conecto';
 }
 } 

Una vez creado, la clase principal que se encuentra ubicada en “App\Personalizado\Conexion\conexion.php”, tendrá como namespace y que es el que podrá ser usado desde cualquier lugar de la aplicación, o sea hacer bind, este:

 App\Personalizado\conexion 

Para que el bind funcione, son necesarios unos pasos más. Lo siguiente que haremos será crear el Service Provider de la clase.

Lo haremos con Artisan desde la consola:

 php artisan make:provider ConexionServiceProvider 

Lo que sigue es registrar la clase en el método register() del  ConexionServiceProvider, haciendo el adecuado bind.

  public function register()
     {
         //registramos la clase
         \App::bind('Conexion');
     }  

Y finalmente registramos ConexionServiceProvider en el fichero de configuración, que  se encuentra en la ruta config/app.php, agregando la clase, dentro del array de providers:

  /*
          * Application Service Providers...
          */
         App\Providers\AppServiceProvider::class,
         App\Providers\AuthServiceProvider::class,
         …………
          /*
          * Clases Propias añadidas...
          */
         App\Providers\ConexionServiceProvider::class,
   

Nos faltaría comprobar que nuestra clase es accesible, podemos hacer diferentes pruebas, como llamar la clase desde una ruta o correr una prueba con Tinker.

Comencemos con Tinker, llamándolo desde la consola:

  >>>php artisan tinker 

Una vez abierto, llamamos la clase, y la corremos :

  Psy Shell v0.9.12 (PHP 7.2.3 — cli) by Justin Hileman
 >>> use App\Personalizado\Conexion; 

La instanciamos :

 >>> $h =new Conexion();
 => App\Personalizado\Conexion {#3106} 

Y llamamos la funcion:

 >>> $h->conectar();
 => "conecto"
 >>>                         

Salimos de Tinker, con control +C.

Tambien podemos probarlo en el sistema de rutas de Laravel.

 Route::get('conectando', function(){
     if(class_exists('App\Personalizado\Conexion'))
     dd('hallada');
     else dd(' no hallada');
 }
 ); 

Si accedemos ahora a la ruta conectando deberíamos ver escrita la palabra hallada.

Ahora, nuestra clase esta lista y disponible para ser usada.

Y listo, esto es todo.

Espero modestamente que este artículo, sirva de ayuda a alguien.

Gracias.

…., si avanzo sígueme, si me detengo empújame, si retrocedo mátame…….

Crear un comando en Laravel

logo laravel

Crear comandos que nos permiten ejecutar acciones manuales desde la consola,  es una herramienta que necesitamos más comúnmente de lo que parece, por eso crear un comando en Laravel, es una buena opción que agiliza el desarrollo.

Hablo por supuesto desde mi humilde experiencia.

El desarrollo me he exigido que además de las herramientas de testeo, en muchos casos correr directamente comandos de Artisan, para comprobar el funcionamiento en vivo de funciones o métodos construidos, como parte del proceso de creación de una aplicación.

En este ejemplo muestro como crear un comando Artisan,  que va a conectarse a un base de datos y hacer una inserción según un momento determinado en ella.

Llamaremos a nuestro comando importar.

En la consola dentro del root de nuestro proyecto creamos el comando:

 php artisan make:command Importar 

Como crear un componente en Laravel

Esto creará nuestro comando, si vamos ahora a la ruta

app/Console/Commands/importar.php, 

el archivo Commands, que se crea al correr

make:command 

tendrá dentro los datos del comando creado.Dentro del comando hay varias zonas importantes:

La primera es la  variable  $signature, que es donde daremos el nombre con que llamaremos al comando en la consola

  protected $signature = 'importar'; 

La  segunda es la variable descripción, allí escribiremos la descripción de la razon de ser del comando que aparecerá cuando listemos los comandos de Artisan

protected $description = 'Insertar productos en la Base de datos';

La tercera zona importante es la función handle en la cual desarrollaremos la lógica.

   public function handle()
     {//

    $archivos =  \Storage::disk('listos')->files(); 
    $ultimo =  end($archivos);
    $contenido_Exp = \Storage::disk('listos')->get($ultimo);

    $contenido_Exp = json_decode($contenido_Exp);
    //dd($contenido_Exp[2]->codigo);
                   /* 
                    ->get(); */
    //dd($archivo);


    function hora_exportar($sitio, $hora)
    {
      $hora = date("H.i.s");
      $hora_deseada  = DB::table('sitios')->hora_deseada;
      if ($hora === $hora_deseada){
        $sitio = DB::table('sitios')->nombre;
        $host = DB::table('sitios')->host_conex;
        $username = DB::table('sitios')->usuario_bd;
        $passwd = DB::table('sitios')->pass_bd;
        $dbname = DB::table('sitios')->nombre_bd; 
      }

     }


    /*
    $host ="154.53….";
    $username =  "admin_bd ";
    $passwd= "Hlnv68?";
    $dbname= "bd_pt";*/


   // $consulta = ;
    $enlace = mysqli_connect($host,$username,$passwd,$dbname);
  /*  if ($mysqli_ping($enlace)){
        printf("conexion bien");
    }
    else{ printf("error de conexion");}
    mysqli_close($enlace);*/
    if(!$enlace){
        echo "Error no se pudo conectar".PHP_EOL;
        echo "Errno de depuracion:".msqli_connect_errno().PHP_EOL;
        echo "Errno de depuracion:".msqli_connect_error().PHP_EOL;
        exit;
    }
    echo "realizada conexion exitosa".PHP_EOL;
    echo "info del host:".msqli_get_host($enlace).PHP_EOL;
    mysqli_close($enlace);


   //insertamos en nuestra bd los datos de la ultima exportacion  
  $insertar_exportacion = DB::table('importaciones')->insert([
              'users_id' => 1,
              'estados_id' => '3',
              'proveedores_id' =>'1',
              'sitios_id' => $ultimo,
              'url_archivo'  => $url,
              'nombre_archivo'  => $url,
              'tipo_archivo'  =>$tipo,
              'tamaño'  =>'1',

             ]);
}

En nuestro ejemplo tenemos una columna en la bd llamada hora deseada, que compareremos con la hora actual del servidor, si el valor es igual  ejecutaremos la consulta.

El ultimo paso para que el comando funcione es declararlo en el  archivo kernel.php dentro de la ruta App/Console, dentro de los comandos protegidos

protected $commands = [
     //     Commands\Importar::class, ]; 

Y en la función Schedule, tenemos la opción de configurar la ejecución  su ejecución periódicamente,  podríamos también colocar una  tarea en el servidor de llamar esta función, a una hora especifica,  en nuestro caso la colocaremos aquí diaria.  

protected function schedule(Schedule $schedule)
     {
          $schedule->command('Importar')
                 ->daily();
     }

Esto es todo, no obstante debemos decir que la recomendación de  Laravel es que los comandos sean ligeros para no cargar demasiado la ejecución del sistema en si y como una buena  práctica de programación.

La mejor opción es aprovechar la reusabilidad, y utilizar ese mismo código dentro de un controlador,  ejecutándolo de  modo periódico, y así dejar la ejecución del comando solo para tareas manuales.

Y listo, esto es todo.

Espero modestamente que este artículo, sirva de ayuda a alguien.

Gracias.

…todo lo que se contiene,  termina  desbordándose……

Creando un componente en Laravel

laravel

¿Que necesidad hay de andar creando un componente en Laravel?

Laravel es un framework basado en componentes y esta es una  de sus características y quizás la mas importante de todas,   que lo hace tan útil, sencillo y potente a la vez.

Los componentes dicho de forma rápida son un conjunto de funciones, scripts  y/u otros elementos que pueden  que crean una funcionalidad y que son reusables.

Piensa en una pieza de ropa  o un accesorio femenino que puedes combinar(usar), con varias otras prendas, sin que pierda funcionalidad, y para diferentes ocasiones y tantas veces como quieras.

Hay diferentes tipos de componentes, voy a centrarme hoy en construir uno en Blade el gestor de plantillas Blade

Un componente en Blade,  cumple la misma función que la combinación entre las directrices section y layouts, por tanto es una alternativa a esta, digamos más moderna.

Consta de dos variables, el component y el slot. Mientras que el component es la estructura general,  slot es la parte dinámica  que inyectaremos en el.

Crear un componente

El primer paso para crear un componente Blade, considerando que va a estar relacionado con las vistas, es colocarlo dentro del área que tiene que ver con las capas(layouts) de las vistas, así que en la ruta resources/views/layouts, creamos una carpeta llamada componentes.

Luego crearemos un  archivo, que contendrá la lógica del componente.

El compenente, que vamos a construir, va a llamarse curric_autor, y se encargará de mostrar  una pequeña nota al final de cada articulo que publiquemos en nuestro blog.

Estará colocado a la izquierda de la página, e incluirá la  foto del autor y un pequeño texto  con su descripción.

 A este archivo lo nombraremos curric_autor.php y lo  guardaremos en la carpeta componentes que hemos creado.

El próximo paso es escribir nuestro código, el cual podría ser este:

 <divclass = flex-row comd-6>
 <div class=d- flexjustify-content-end col-md-9>
 <spanclass= text-justify> Amante del codigo, y de las mascotas  con garras.</span>
 <divclass="text-center col-md-3">
<imgsrc="..."class="rounded"alt="...">
</div>
</div>
</div> 

Una vez creado el componente podemos usarlo de diferente modo:

Podemos llamarlos desde nuestra vista e inyectarlo  en la vista siguiendo las directivas @ de Blade.

  @component('layouts.components.curric_autor')
 @endcomponent 

Con esto será suficiente, pero ¿que sucede si en el blog publica más de un autor y por tanto los datos que usamos necesitan ser extraidos dinámicamente de la base de datos?

Tendríamos entonces que añadir en el código del componente  variables necesarias para  que recojan esta dinámica, y lo haríamos  con $autor que representará al modelo autor que posee varios atributos, lema, avatar_alt y avatar, y para añadirlos seria asi:

  <div class = flex-row col-md-6  >
 <div class=d- flexjustify-content-end col-md-9>
 <spanclass= text-justify> {{$autor->lema}}.</span>
 <divclass="text-center col-md-3">
<imgsrc="{{$autor->avatar}}..."class="rounded"alt=" {{$autor->avatar_alt}}">
</div>
</div>
</div> 

Una alternativa es que no extraigamos valores de la base de datos y solo necesitemos introducir variables que llevan valores estaticos.

 <div class = flex-row col-md-6  >
 <div class=d- flexjustify-content-end col-md-9>
 <spanclass= text-justify> {{$autor}}.</span>
 <divclass="text-center col-md-3">
<imgsrc="{{$avatar}}..."class="rounded"alt=" {{$avatar_alt}}">
</div>
</div>
</div>
  

Llamar al componente

Ahora al llamar el componente desde la vista añadiríamos la directiva slot que es la encargada de traernos el valor de esas variables.

 @component('layouts.components.navbar')
 @slot('autor')
 colocamos aquí el valor 
 @endslot
 @slot('avatar')
 colocamos aquí el valor 
 @endslot
 @endcomponent
 @slot('avatar_alt')
 colocamos aquí el valor 
 @endslot 

Esto pudiéramos hacerlo también de otro modo, gracias a la ductilidad de Laravel. Esta via por cierto es un poco más robusta.
Para ello declararemos, nuestro componente en el proveedor de servicios de Laravel, en su función boot()

Leer mas sobre Laravel

Antes de hacer esto debemos decirle al proveedor de servicios que vamos a usar una instancia de la fachada Blade, asi que tendremos que incluir al inicio la sentencia.

 use Illuminate\Support\Facades\Blade;

//Luego podemos ya incluir en la función boot, lo siguiente:

 Blade::component('layouts.components.curric_autor,'autor'); 

Con esto le estamos diciendo a Laravel primero donde se encuentra el componente, y segundo nombre que utulizaremos para llamarlo, entendemos entonces que la  estructura es:

(ruta o namespace del componente, alias del componente)

Entonces, ahora podremos llamar al componente, desde cualquier lugar con la directriz @y su alias, en nuestro caso será:

@autor

Quedando el modo de llamar a nuestro componente como:

@autor(['autor'=>'valor', 'avatar'=>'valor', 'avatar_alt'=>'valor',]) @endautor

Y listo, esto es todo.

Espero modestamente que este artículo, sirva de ayuda a alguien.

Gracias.

….un sueño es casi todo  y más que  nada, más que todo al soñarlo, casi nada después……