TypeError: static() got an unexpected keyword argument ‘document_root’ in Django”

logo django

Este error puede aparecer, en Django cuando intentamos añadir en nuestro urls.py

+= static(settings.MEDIA_URL, documnet_root=settings.MEDIA_ROOT)

Esta modificación de las urls, la hacemos para decirle a Django, en qué lugar se encuentran nuestros archivos media.

Si nos fijamos en el contenido de nuestro archivo settings.py, debe aparecer la dirección que indica , dónde guardamos nuestros archivos estáticos y en que lugar nuestros archivos tipo media.

Es algo asi

MEDIA_URL = '/media/'
 MEDIA_ROOT = os.path.join(os.path.dirname(BASE_DIR), 'media')
 STATIC_URL = '/static/' 

Dicho esto, el error puede proceder de diversas fuentes, dos de las que conozco y me resultan más comunes son:

 Importar de modo incorrecto la ruta del método static utilizando:

 from django.templatetags.static import static

cuando deberiamos importar

 from django.conf.urls.static import static   

El primero de ellos nos permite manejar archivos estáticos, como css, javascript o imágenes.

El segundo  es una una función helper que nos devuelve la  url,  donde se encuentra un contenido especifico  y su estructura es:

static.static(prefixview=django.views.static.serve**kwargs)

import *

Si, así es. El segundo error es emplear el uso de import *, que por más que pueda parecer cómodo , me ha traído algún de un dolor de cabeza.

En este articulo pueden ampliar conocimiento sobre sus inconvenientes.

“….El amor siempre empieza soñando y termina en insomnio“

R.Arjona

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

Este error 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”

Fusionar dos diccionarios en Python 3.5

logo python

Fusionar dos diccionarios en Python 3.5, es algo que puede resultar común en nuestra aplicación.

El procedimiento varia según la versión de Python que usemos, en nuestro caso es la 3.5 , siguiendo las indicaciones de las convenciones PEP 448

Lo que obtenemos es un nuevo diccionario t , con todos los valores, donde están sobreescritos los valores del segundo diccionario (b), por los del primero (a)

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

Gracias

“….El amor siempre empieza soñando y termina en insomnio“

JArjona

Cambiar el nombre a una columna con Pandas

logo python

Las vías que conozco,  para cambiar el nombre a una columna son tres . Podemos hacerlo con el método rename(), el cual puede aplicarse directamente a la columna, o pasarlo a través de una funcion lambda.

Ojo, es posible que haya más posibilidades, me refiero a las que uso y conozco.

Cambiar el nombre a una columna con Pandas

El método rename(),  se utiliza justo para modificar la etiqueta de los ejes, al aplicarlo nos devolverá un nuevo dataframe con los valores aplicados. Su sintaxis es:

dataframe.rename(mapper=None, index=None, columns=None, axis=None, copy=True, inplace=False, level=None, errors='ignore')

maper: Ya sea un diccionario o una función , indica las transformación a aplicar  al eje dado. Este parámetro y el eje se emplean para indicar que valores y ejes recibirán el cambio.

index: Nos permite establecer el eje. Si empleamos maper, index =0 , es lo mismo que maper = index

columns: Indica las columnas, si su valor es cero o se ignora, significa que es el mismo que maper.

axis: tiene por defecto el valor 0, que indica el índice, el valor 1 indica columnas. Pueden emplearse colocando el nombre del eje(índice, columnas), o el numero (0,1). El valor que recibe por defecto es el del índice.

copy: Su valor determinado es True, y esto garantiza copiar también los datos subyacentes.

inplace: valor por defecto False, si se convierte a True, al devolver el nuevo dataframe la copia anterior se ignora.

level: valor por defecto None, indica el numero o nombre del nivel. Si existen índices multiples solo modificara en el nivel indicado.

error: acepta raise o ignore, y ese último es su valor por defecto. Ignora el error del tipo keyerror, cuando index o columns contienen etiquetas que no existen.

Tenemos el siguiente dataframe:

Aplicándolo directamente seria algo asi:

Renombramos varias columnas usando mapping en las columnas Unnamed: 0 e Ischaemic heart disease, para ello pasamos los valores nuevos, en forma de diccionario.

Renombremos ahora los indices

Esto también podría lograrse escribiendo

data_df.rename({0: 'Año1', 1: 'Año1', 2: 'Año3'}, axis='index')

Incluso podemos cambiar el estilo :

A través de una función lambda:

Y esto es todo

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

Gracias

…. hay que levantarse cada mañana con una esperanza y dormirse cada noche con una meta….

Y

Análisis de regresión simple.Python

logo python

En este post realizaré un análisis de regresión, en el que tomaremos una set de datos preparado previamente.

El problema real al que nos enfrentamos, es determinar la relación que pueda existir entre la cantidad de ventas de la empresa “El Dorado”, y el numero de vendedores que la han integrado durante el periodo que se estudia, que son 36 meses o sea los últimos 3 años.

El departamento ha cambiado de responsable en varias ocasiones, y cada uno ha aplicado políticas diferentes de ventas, algunas intensivas, buscando mayor productividad en las ventas, a bases de estímulos como bonos, primas, ascensos,  etc; y en otras ocasiones, en cambio,  se han aplicado medidas extensivas incrementando el numero de vendedores, en una afán por ampliar la cobertura de ventas.

Lo que vamos a hacer es implementar un análisis de regresión lineal.

La regresion lineal es una técnica estadística, que el machine learning adoptó y que incluye como uno de los algoritmos supervisados.

He escrito hace unos meses algún articulo sobre regresion lineal y resumiendo lo que hara este análisis es obtener una recta que se acerque lo mas posible a todos los puntos de datos representados en un plano.

En nuestro caso es una regresion simple (participan dos variables ) y la recta que buscamos obtener es, la mejor posible.

Esto quiere decir que de todas las rectas esta sea la que mejor se adapte al conjunto de puntos, lo que le permitirá tendencialmente  estimar o predecir valores, dentro del contexto de datos estudiados.

La recta tiene forma esta forma Y = mX + b;  donde Y es el resultado obtenido, X es la variable, m la pendiente (o coeficiente) de la recta y b el valor constante, que gráficamente expresa el “punto donde cuando X tiene valor cero, se produce la intercepción o corte con el eje Y.

 Su optimización o ajuste se logra aplicándole una función llamada de mínimos cuadráticos, o también conocida de error cuadrático.

Su nombre obedece a que esa funcion intenta minimizar el error existente entre los puntos o dados y los obtenidos, elevendo al cuadrado sus valores para evitar que se anulen.

De este modo el algoritmo, se centra en minimizar el coste de dicha función

Recordemos que los algoritmos de Machine Learning Supervisados, aprenden por sí mismos.

Utilizaremos un archivo de datos que ya tenemos, y que muestra el número de  ventas y vendedores por meses; o sea tendremos dos columnas: vendedores y ventas.

Y nuestro en nuestro análisis de regresión, lo que vamos a intentar  es determinar a partir de los vendedores que tenemos,  que valor podemos esperar en la ventas de acuerdo, a la relación dada entre ambas variables.

Trabajaremos con Jupiter Notebook,utilizaremos las librerías Pandas, SkLearn, Seaborn, Numpy, de modo que comenzaremos por ahí.

Importamos las librerías

Cargamos nuestro archivo en un dataset de pandas después de leerlo, definiendo el separador de columnas.

Adquirimos  la información de nuestro dataset, con el método info(). Observamos que tenemos dos tipos de datos : enteros en columna vendedores y decimales en la columna ventas.

Comprobamos la estructura del dataset, con el método shape, que nos dice que tenemos efectivamente dos columnas y 36 registros en cada una.

Con head(), visualizamos las 6 primeras filas de nuestro dataset

Convertimos por comodidad la columna venta a tipo entero, empleando el método astype() y guardamos esa transformación en un nuevo dataset, que es con el que continuaremos trabajando.

Definimos con columns(), los encabezados de las columnas

Obtenemos los valores estadísticos de nuestro dataset con el método describe()

Observamos entre otros valores,  que la media de vendedores es 23, con una desviación de 4,63; mientras que la de ventas es 42 millones y su desviación es de 7.12.

Visualizamos los datos, en gráficos, mostrando las columnas por separados

Empleando scatter mostramos  los puntos coloreados, separando los colores a partir de la media de vendedores (23)

En este punto creamos nuestra recta de regresion y visualizamos los coeficientes que la componen nuestra recta.

Nuestro error cuadrático no es elevado pero es alto y nuestra varianza esta más cerca de 0 que de 1, por lo que este modelo tal vez podría mejorarse.

La intersección (b), tiene un valor de 9,67…. donde se corta la recta cuando el valor en X es 0

En función de observar el comportamiento del modelo, asignamos valores diferentes para ver su comportamiento

Ahora visualicemos la recta dentro de nuestro gráfico

Podemos observar nuestros datos de diferentes formas, en este caso con la librería seaborn, vemos el comportamiento de los datos en los diferentes periodos y su relación.

Para mejorarla tenemos varios caminos, podemos aplicar métodos como el gradiente, podemos hurgar en los datos y añadir más variables predictivas, referidas por ejemplo a la competencia, la innovación o la aceptación de los productos, pasando de una regresión simple a una regresión múltiple, podríamos también ampliar la cantidad de registros buscando mas años, desechar los valores extremos, etc.

En otros artículos iré aplicando algunos de estos métodos, haciendo referencia a estos mismos datos.

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

Gracias

“El amor es la guerra perdida, entre el sexo y la risa”

R.Arjona

Creando conexiones dinámicas en 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;

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

Si estamos trabajando con un cliente conectado a proveedores, y necesitamos  desarrollar alguna api que importa un archivo remoto, de modo automático  y lo guarde  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 trabaja con clases que generalmente se guardan en repositorios desde el cual son llamadas. Esta estructura requiere que ademas de conocer la organizacion del framework, comprendamos su enfoque para crear, almacenar y gestionar las claves.

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 mas comúnmente de lo que parece, hablo por mi 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 

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

¿Por que crear componentes?

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?

Tendriamos entonces que qñadir en el codigo 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>
  

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()

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……