ejemplos archivos - KumbiaPHP Framework PHP en español

Chatbots inteligentes en PHP con KumbiaPHP

HenryStivens — Fri, 07 Nov 2025 06:00:00 +0000

¿Qué es un chatbot inteligente?

Un chatbot con PHP es un asistente virtual que usa inteligencia artificial para simular una conversación natural con usuarios, realizando tareas como responder preguntas, agendar citas, brindar soporte técnico y más. Implementar un chatbot inteligente utilizando PHP puede potenciar significativamente tu aplicación web.

Veremos paso a paso cómo configurar las dependencias, conectar con el modelo GPT-4 y construir una interfaz simple que permita interactuar con el asistente directamente desde tu aplicación web.

Herramientas recomendadas para crear chatbots con PHP

OpenAI API: Facilita el acceso a modelos avanzados como GPT-4 para procesamiento de lenguaje natural y es ideal para construir un chatbot con PHP.
Dialogflow: Servicio gestionado de Google que simplifica la creación de interfaces conversacionales y puede integrarse fácilmente como chatbot con PHP.
Rasa: Alternativa open source para chatbots personalizados y con mayor control, perfecta para crear un chatbot con PHP.

Creando un chatbot con PHP y KumbiaPHP usando la API de OpenAI

Paso 1: Instalar dependencias

Usa Composer para instalar la librería oficial de OpenAI para tu chatbot con PHP (Packagist de
OpenAI PHP):

composer require openai-php/client

Paso 2: Configuración específica para OpenAI

Crea un archivo específico para la configuración en config/openai.php para tu chatbot con PHP:

 'TU_API_KEY',
    'model' => 'gpt-4-turbo',
    'systemPrompt' => 
        'Eres un asistente útil. Te llamas Kumbita y amas Kumbiaphp',
];

Paso 3: Crear modelo para lógica de OpenAI

Crea el archivo app/models/open_ai_model.php, esencial para desarrollar un chatbot con PHP:

config = $config ?? Config::read('openai');
        $this->client = OpenAI::client($this->config['api_key']);
    }

    /**
     * Obtiene la instancia única del servicio
     *
     * @param array Configuración (opcional)
     * @return OpenAiModel
     */
    public static function getInstance(?array $config = null): self
    {
        return self::$instance ??= new self($config);
    }

    /**
     * Obtiene el cliente OpenAI
     * 
     * @return Client
     */
    public function getClient(): Client
    {
        return $this->client;
    }

    /**
     * Envía un mensaje a OpenAI y recibe la respuesta
     * 
     * @param string $message El mensaje del usuario
     * @param string $systemPrompt El prompt del sistema (opcional)
     *
     * @return string La respuesta del modelo
     */
    public function sendMessage(string $message, ?string $systemPrompt = null): string
    {
        $response = $this->client->chat()->create([
            'model' => $this->config['model'],
            'messages' => [
                [
                  'role' => 'system',
                  'content' => $systemPrompt ?? $this->config['systemPrompt']
                ],
                [
                  'role' => 'user',
                  'content' => $message
                ],
            ],
        ]);

        return $response->choices[0]->message->content;
    }
}

Paso 4: Crear controlador Chatbot en KumbiaPHP

data = match ($message) {
            null, '' => [],
            default =>  ['reply' => OpenAiModel::getInstance()->sendMessage($message)],
        };
    }
}

Paso 5: Crear la vista del chatbot en KumbiaPHP

Crea la vista index.phtml en app/views/chatbot/ para interactuar fácilmente con tu chatbot con PHP:


    Chatbot Inteligente con PHP y KumbiaPHP

    
        
            Kumbita: Hola, me llamo Kumbita. ¿Qué quieres saber hoy?

Ventajas de usar chatbots en aplicaciones PHP

Disponibilidad 24/7.
Respuestas inmediatas y personalizadas.
Optimización de recursos humanos y reducción de costos operativos.

Este ejemplo constituye una base sólida para comprender cómo integrar inteligencia artificial en tus proyectos PHP con KumbiaPHP. A partir de aquí, puedes ampliarlo añadiendo manejo de historial de conversación, personalización de prompts del sistema, validaciones adicionales de entrada, o incluso mecanismos de seguridad para evitar abusos en el endpoint.

Al finalizar esta guía, tendrás un chatbot completamente funcional listo para integrarse en cualquier proyecto desarrollado con KumbiaPHP. Anímate a probarlo, experimentar con sus respuestas y descubrir el potencial de combinar la sencillez de PHP con la potencia de la inteligencia artificial. Si te ha resultado útil, comparte este artículo o deja tus comentarios en el blog para seguir mejorando juntos.

Agradecimientos

Agradecemos especialmente a @joanhey por tomarse el tiempo de revisar y mejorar el código de ejemplo, aportando sugerencias valiosas que ayudaron a hacerlo más claro y funcional para la comunidad de desarrolladores de KumbiaPHP.

La entrada Chatbots inteligentes en PHP con KumbiaPHP se publicó primero en KumbiaPHP Framework PHP en español.

Buscador avanzado de texto completo para KumbiaPHP con Meilisearch

HenryStivens — Sat, 19 Apr 2025 08:00:00 +0000

Si estás buscando implementar un buscador avanzado de texto completo para KumbiaPHP con Meilisearch, este artículo te mostrará cómo hacerlo de manera sencilla, efectiva y escalable. Descubre cómo aprovechar todo el potencial de Meilisearch en tus aplicaciones KumbiaPHP, ofreciendo a tus usuarios búsquedas rápidas y resultados altamente relevantes.

¿Por qué utilizar un buscador avanzado de texto completo para KumbiaPHP con Meilisearch?

Implementar un buscador avanzado de texto completo para KumbiaPHP con Meilisearch permite llevar las capacidades de búsqueda de tus aplicaciones a otro nivel. Meilisearch es un motor de búsqueda rápido, potente y de fácil configuración, ideal para aplicaciones modernas que requieren búsquedas en tiempo real, autocompletado y manejo de grandes volúmenes de datos.
Además, gracias a sus capacidades de búsqueda semántica impulsada por inteligencia artificial, se pueden obtener resultados mucho más precisos incluso cuando las palabras de búsqueda no coinciden exactamente con los términos indexados.

Requisitos

Antes de comenzar a integrar un buscador avanzado de texto completo para KumbiaPHP con Meilisearch, verifica que tu entorno cumpla con los siguientes requisitos básicos:

Tener una aplicación funcionando con KumbiaPHP 1.2 o superior.
Tener PHP 8.0 o superior.
Tener acceso al servidor o contenedor donde correrá Meilisearch.
Instalar el cliente de Meilisearch para PHP con Composer:

composer require meilisearch/meilisearch-php \
guzzlehttp/guzzle \
http-interop/http-factory-guzzle:^1.0

Instalar el nuevo ActiveRecord de KumbiaPHP si aún no lo tienes:

composer require kumbia/activerecord

Este nuevo ActiveRecord es un componente externo que puedes usar en cualquier proyecto PHP, y es requerido para que los modelos soporten los callbacks usados por el trait MeilisearchSearchable.

Configuración del Cliente Meilisearch

Crea el archivo default/app/config/meilisearch.php con la siguiente estructura:

 'http://127.0.0.1:7700', // Change the host
    'api_key' => '', // Change the key
];

Trait MeilisearchSearchableTrait

Crea el archivo default/app/libs/meilisearch_searchable_trait.php con el siguiente código:

index(static::searchableAs())
            ->addDocuments([$this->toSearchArray()]);
    }

    /**
     * Callback executed after a model is updated.
     * The updated record is synchronized in the MeiliSearch index.
     */
    protected function _afterUpdate(): void
    {
        self::getMeiliClient()
            ->index(static::searchableAs())
            ->updateDocuments([$this->toSearchArray()]);
    }

    /**
     * Deletes a record and synchronizes the deletion with the MeiliSearch index.
     */
    public static function delete($pk): bool
    {
        $deleted = parent::delete($pk);

        if ($deleted) {
            self::getMeiliClient()
                ->index(static::searchableAs())
                ->deleteDocument($pk);
        }

        return $deleted;
    }

    /**
     * Performs a search query on the MeiliSearch index.
     */
    public static function search(string $query, array $options = []): array
    {
        $results = self::getMeiliClient()
            ->index(static::searchableAs())
            ->search($query, $options);

        return $results->getHits();
    }

    /**
     * Bulk-imports existing records into the MeiliSearch index.
     */
    public static function importToMeilisearch(int $chunkSize = 500): void
    {
        $offset = 0;

        do {
            $records = static::filter("LIMIT $chunkSize OFFSET $offset");
            $data    = [];

            foreach ($records as $record) {
                $data[] = $record->toSearchArray();
            }

            if (!empty($data)) {
                self::getMeiliClient()
                    ->index(static::searchableAs())
                    ->addDocuments($data);
            }

            $offset += $chunkSize;
        } while (count($records) === $chunkSize);
    }
}

Ventajas del Trait MeilisearchSearchable

Integración simple: Reutiliza fácilmente la funcionalidad en múltiples modelos.
Automatización: Mantiene sincronizados automáticamente tus modelos con el índice de búsqueda.
Flexibilidad: Puedes personalizar fácilmente el comportamiento de búsqueda por cada modelo.
Inteligencia Artificial: Soporte para búsqueda semántica mediante integración con IA (OpenAI u otros proveedores).

Cómo utilizar en la práctica un buscador avanzado de texto completo para KumbiaPHP con Meilisearch

Paso 1: Implementación en Modelos

A continuación, integra el trait en tus modelos que extiendan de LiteRecord:

Ejemplo con Modelo Product

 $this->id,
            'name' => $this->name,
            'description' => $this->description,
            'price' => $this->price,
        ];
    }
}

Ejemplo con Modelo Article

 $this->id,
            'title' => $this->title,
            'content' => $this->content,
            'author' => $this->author,
        ];
    }
}

Una vez implementado el trait en tus modelos, realizar búsquedas será simple y eficaz. Estos ejemplos prácticos ilustran claramente cómo aprovechar tu nuevo buscador avanzado de texto completo para KumbiaPHP con Meilisearch.

Paso 2: Realizar búsquedas fácilmente

Ahora puedes realizar búsquedas en tus modelos:

// Buscar productos
$products = Product::search('zapatos deportivos', ['limit' => 10]);

// Buscar artículos
$articles = Article::search('tecnología', ['limit' => 5]);

Paso 3: Importar datos existentes

Si ya tienes datos almacenados en tu base de datos, puedes importarlos fácilmente:

Product::importToMeilisearch();
Article::importToMeilisearch();

Ejemplo de Mielisearch con Controlador y Vista en KumbiaPHP

Paso 1: Crea el controlador

Controlador: app/controllers/products_controller.php

class ProductsController extends AppController
{
    public function search()
    {
        if (Input::hasPost('query')) {
            $this->results = Product::search(Input::post('query'));
        }
    }
}

Paso 2: Crea la vista

Vista: app/views/products/search.phtml

Buscar productos




    
    



    No se encontraron resultados.
    


Resultados

    
        
            

            

            Precio: $

La combinación de KumbiaPHP con Meilisearch a través del trait MeilisearchSearchable te permite ofrecer una experiencia superior en búsquedas a tus usuarios. Con la posibilidad de usar IA para búsquedas semánticas, la calidad de los resultados se eleva aún más. La integración es simple, escalable y potente, haciendo que valga la pena el esfuerzo inicial.

¡Prueba esta integración y lleva tus búsquedas al siguiente nivel con KumbiaPHP y Meilisearch!

La entrada Buscador avanzado de texto completo para KumbiaPHP con Meilisearch se publicó primero en KumbiaPHP Framework PHP en español.

Optimizando la Renderización Condicional en Vistas de KumbiaPHP con return 1;

HenryStivens — Mon, 14 Oct 2024 16:52:23 +0000

En el desarrollo web, especialmente al trabajar con motores de plantillas o frameworks MVC como KumbiaPHP, es común renderizar condicionalmente partes de una vista basándose en la disponibilidad de datos. Tradicionalmente, los desarrolladores utilizan sentencias if-else para controlar el flujo de renderización de la vista. Sin embargo, el uso excesivo de bloques if-else puede desordenar tu código y dificultar su mantenimiento.

En este artículo, exploraremos una forma más limpia y eficiente de gestionar la renderización condicional en KumbiaPHP con return 1;. También profundizaremos en por qué este enfoque es preferible sobre el uso estándar de return; o estructuras if-else anidadas.

El Enfoque Tradicional: Uso de if-else

Considera un escenario donde quieres mostrar un mensaje si no hay datos para mostrar y renderizar el resto de la vista solo cuando los datos están disponibles. Un enfoque típico podría verse así:


    No hay productos disponibles

    Lista de Productos
    
        
            
                nombre ?>
                imagen_url ?>" alt="nombre ?>" />
                Categoría: categoria ?>
                Descripción: descripcion ?>
                Precio: $precio, 2) ?>
                Stock: stock ?> unidades disponibles
                SKU: sku ?>
                Ver Detalles

Aunque esto funciona, envolver todo el código de la vista dentro de un bloque else añade una indentación y complejidad innecesarias, especialmente en vistas más grandes.

Renderización condicional en KumbiaPHP con return 1; Una Solución Más Limpia:

Para mejorar la legibilidad y mantener el código más limpio, podemos utilizar return 1; para salir de la vista de manera anticipada si no hay datos. Aquí está cómo se vería el código:

No hay productos disponibles";
    //View::partial('sin-datos'); // o enviamos un partial
    return 1;
}?>

Lista de Productos

    
        
            nombre ?>
            imagen_url ?>" alt="nombre ?>" />
            Categoría: categoria ?>
            Descripción: descripcion ?>
            Precio: $precio, 2) ?>
            Stock: stock ?> unidades disponibles
            SKU: sku ?>
            Fecha de Lanzamiento: fecha_lanzamiento)) ?>
            Calificación: calificacion ?> estrellas
            Ver Detalles

En este ejemplo:

Si $products está vacío o es false, se muestra el mensaje «No hay productos disponibles» y la ejecución de la vista se detiene gracias a return 1;.
Si $products tiene datos, el código continúa ejecutándose y se muestra la lista detallada de productos sin necesidad de un bloque else.
El código es más limpio y fácil de leer al eliminar la indentación adicional.

Aplicación en Templates y Partials

La misma técnica puede aplicarse en templates y partials. Esto es útil cuando necesitas condicionar la inclusión de ciertas secciones o elementos de la interfaz de usuario.

Ejemplo en un Partial

En un partial que muestra comentarios de un artículo:

No hay comentarios aún. ¡Sé el primero en comentar!";
    return 1;
}?>


     Comentarios
    
        
            autor ?> dice:
            contenido ?>
            Publicado el fecha_publicacion)) ?>

Entendiendo View::render() y include

En KumbiaPHP, las vistas se renderizan usando el método View::render(), que internamente incluye el archivo de vista:

// Carga la vista
if (!include self::getView()) {
    throw new KumbiaException('Vista "' . self::getPath() . '" no encontrada', 'no_view');
}

La sentencia include en PHP devuelve false si falla al cargar el archivo (debido a que el archivo no existe, falta de permisos, etc.). Si el archivo incluido ejecuta un return; sin un valor, devuelve null, lo que la validación del include se interpreta como false. Esto lleva a que View::render() crea que el archivo de vista no pudo ser incluido y lanza una excepción.

La Importancia de return 1;

Al usar return 1;, la vista devuelve 1, lo que include interpreta como una inclusión exitosa. Esto permite que el proceso de renderización continúe sin problemas sin desencadenar una excepción.

Beneficios de Usar return 1;

Código Más Limpio: Al eliminar bloques else innecesarios, el código es más sencillo y legible.
Facilidad de Mantenimiento: Menos indentaciones y anidaciones facilitan la comprensión y modificación del código en el futuro.
Consistencia: Puedes aplicar esta técnica en vistas, templates y partials de manera uniforme.
Mayor Claridad: Separar la lógica de control del contenido principal mejora la claridad y organización del código.

Conclusión

Usar return 1; en las vistas de KumbiaPHP es una forma simple pero efectiva de gestionar la renderización condicional sin complicar tu código con estructuras if-else innecesarias. Asegura que tus vistas se ejecuten sin problemas y que el proceso de renderización continúe sin excepciones.

Al adoptar este enfoque, puedes escribir vistas más limpias y mantenibles en tus aplicaciones KumbiaPHP. Pruébalo en tu próximo proyecto y experimenta la diferencia que hace en tu base de código.

¡Feliz codificación con KumbiaPHP!

La entrada Optimizando la Renderización Condicional en Vistas de KumbiaPHP con return 1; se publicó primero en KumbiaPHP Framework PHP en español.

Formularios a base de datos fácilmente con 1 línea de código

HenryStivens — Mon, 27 May 2019 16:16:18 +0000

En KumbiaPHP existe una implementación que ahorra muchísimo trabajo a la hora de hacer formularios y la intención es aprovechar al máximo las bondades que ofrece el framework. En este sentido tenemos la Autocarga de objeto, la cual, como su nombre indica asocia un campo de formulario a una tabla y campo de la base de datos.

DDL y modelo para la tabla

Veamos la estructura de la tabla user que hemos visto en ejemplos anteriores:

CREATE TABLE `user` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 `name` varchar(255) NOT NULL,
 `age` int(11) NOT NULL DEFAULT '0',
 `email` varchar(255) NOT NULL, 
 PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

Y el modelo para este caso lo haremos heredar de la clase ActiveRecord y lo ubicamos en default/app/models/user.php





Implementación de la autocarga de objeto



KumbiaPHP implementa la Autocarga de objeto la cual, siguiendo una convención mínima modelo.campo donde para el ejemplo el modelo es user, es decir existe una tabla llamada user en la base de datos y campo serán cada una de las columnas de esa tabla (id, name, age, email).



En concordancia con las columnas de la tabla user se indica el comportamiento de la Autocarga de objeto para que el controller no tenga que recoger uno a uno los valores enviado por POST.



Para este caso usaremos el helper Form:



Archivo: default/app/views/user/create.phtml






 







Automáticamente cuando esos valores vayan a la url /user/create KumbiaPHP interpreta que existe una tabla user con los campos name, email y age.









Aplicando autocarga en el controlador



Ahora vemos el código que se utiliza en controllers/user_controller.php en su acción create().



Archivo: default/app/controllers/user_controller.php



create(Input::post('user'))) {
            //Mensaje de éxito 
            Flash::valid('Usuario creado');
            //Elimina los datos del POST, muestra limpio el formulario
            Input::delete();
            return;
        }
        //Mensaje de fallo 
        Flash::error('Falló al intentar crear el usuario');
    }
}



Si probamos el formulario y por alguna razón falla al guardar, automáticamente mostrará el formulario con los datos que se intentaron guardar, sin que debamos estar verificando si hay datos en el POST y si los hubiera indicarle al input el value, ya que el helper Form lo hace por nosotros.







Con esto se ahorra mucho trabajo y le sacamos el máximo provecho a KumbiaPHP Framework.



Acceder a un campo del formulario enviado mediante POST



A veces nos consultan como se accede a un campo específico del formulario que viene en el POST en el controlador, y es muy sencillo veamos qué valor trae Input::post(‘user’):



array(3) {
  ['name']=>
  string(8) "John Doe"
  ['email']=>
  string(12) "jd@email.com"
  ['age]=>
  int(30)
}




Como pueden ver al hacer un var_dump() de la variable nos muestra que es un simple arreglo por lo tanto la manera de acceder es la siguiente:



$name = Input::post('user.name');
// or
$name = Input::post('user')['name'];



Son casos especiales y lo mejor es que aprovechen al máximo la autocarga.



Error común de novatos



Es común ver en quienes inician con KumbiaPHP cometer varios errores y uno de ellos es crear el objeto o registro campo por campo. Lo vemos mejor en el siguiente código de la función create() del controlador UserController:



public function create()
{
    //se verifica si se ha enviado via POST los datos
    if (Input::hasPost('user')) {
        $data = Input::post('user');
        //Código incorrecto: Obtener del POST el valor de
        //cada input y asignarlo uno a uno al objeto.
        $user = new User();
        $user->name = $data['name'];
        $user->email = $data['email'];
        $user->age = $data['age'];
        //Intenta guardar el usuario
        if ($user->create()) {
            //Mensaje de éxito
            Flash::valid('Usuario creado');
            //Elimina los datos del POST, muestra limpio el formulario
            Input::delete();
            return;
        }
        //Mensaje de fallo
        Flash::error('Falló al intentar crear el usuario');
    }
}



Funciona si, pero como pueden notar, se agregaron para este caso cinco líneas de código innecesarias. Ahora imaginen que no son tres campos en el formulario, si no que son diez, veinte o más campos por formulario. Ahora multipliquemos eso por el número de formularios de toda la aplicación.



El código creado sería muy extenso y se convierte en difícil de leer y mantener.



Espero que les sea de utilidad este artículo.



PD: Agradecimientos a Deivinson Tejeda por el borrador de este artículo.


La entrada Formularios a base de datos fácilmente con 1 línea de código se publicó primero en KumbiaPHP Framework PHP en español.



Exportar tabla HTML a PDF
HenryStivens — Sun, 28 Apr 2019 23:29:56 +0000

En esta segunda parte veremos como exportar una tabla HTML a PDF usando la librería mPDF. Si no has visto la primera parte este es el primer artículo: Crear PDF usando HTML donde aprendimos a crear un PDF usando partials y funciones en un modelo.



[Actualización: Abril 2020] Hemos creado un nuevo repositorio llamado Sandbox en Github  donde van a estar todos los ejemplos y que podrán visualizar en vivo en la página KumbiaPHP Framework Examples por lo tanto el código se ha mejorado y los links han cambiado.



Template PDF



Un template permite ahorrar código que se repite en la vistas, permitiendo así un fácil mantenimiento y separación del contenido. Realizará la carga de librería, la cabecera y el pié de página y por supuesto el contenido que queremos mostrar.



Para los que aun no han visto el tema de templates en KumbiaPHP o tienen dudas de su funcionamiento los invito a leer la sección sobre el manejo de vistas en KumbiapHP. A continuación el código completo del template y más abajo con capturas se explica cada parte importante.







Archivo: app/views/_shared/templates/pdf/mpdf.phtml








    <?= $title ?>
    
    
    
    


    
        
            
            Powered by
        
    

    

    
        
            {DATE d/m/Y}
            {PAGENO}/{nbpg}
        
    



 APP_PATH . 'temp/mpdf',
    'format' => 'A4',
    'title2annots' => true,  // convert headers  in annotations
    'mirrorMargins' => 0,    // mirror the left and right margin values on odd and even pages 
    'exposeVersion' => false // security 
    // more variables in https://mpdf.github.io/reference/mpdf-variables/overview.html
]);

// Escribe el contenido HTML (Template + View):
$mpdf->WriteHTML($html);

// Genera el PDF, ya sea para su descarga o visualización en el navegador
$mpdf->Output("$fileName.pdf", $destination);




El proyecto ya usa el autoload de composer para tener disponible mPDF y simplemente importa Mpdf\Mpdf. Luego se definen algunas variables para personalizar el PDF y se ejecuta la función ob_start(). «Esta función activará el almacenamiento en búfer de la salida. Mientras dicho almacenamiento esté activo, no se enviará ninguna salida desde el script (aparte de cabeceras); en su lugar la salida se almacenará en un búfer interno.»



Si desean conocer como agregar encabezados y pies de páginas con mPDF un compañero realizó un manual en la Wiki de KumbiaPHP que muestra como agregarlos usando las funciones explicadas en el artículo anterior: Exportar a PDF con cabecera y pie de pagina



Ahora en el  definimos el contenido de la cabecera y el pie de página, y entre ellos la función View::content() que nos permite mostrar el contenido de la vista.



Contenido del Body



mPDF maneja sus propias etiquetas, van entre llaves {} y usamos algunas de ellas:



DATE: Para mostrar la fecha actual
PAGENO: Número de la página
nbpg: Número total de páginas del documento



Y la parte final del template es la que se encarga de unir el template con la vista, generar el PDF con ese contenido y hacer que el documento se visualice o descargue.



General el PDF con el contenido HTML



Controlador PHP



Vamos a crear una nueva vista y para ello empezamos con el método que llamaremos pdf() en el controlador templates_examples_controller.php El código se encuentra explicado entre líneas.



Archivo: app/controllers/templates_examples_controller.php



public function pdf()
{
    //Usa el tempalte 'pdf'
    View::template('pdf/mpdf');
    //Modifica el nombre del archivo a descargar
    $this->fileName = 'user-list';
    //Modifica el título del documento PDF en la cabecera
    $this->title = 'User List';
    $this->download = false;

    $this->data = User::all(); // data to show (model User from db)
}



Vista HTML



Ahora crearemos la vista la cual tendrá la tabla, recorriendo uno a uno los registro de la consulta realizada por el modelo en el controlador.



Archivo: app/views/templates_examples/pdf.phtml 




    No hay ningún registro 

    
    
        
            
                First Name
                Last Name
                Email
                Birthdate
            
        
         
            
                
                    first_name ?>
                    last_name ?>
                    email ?>
                    birthdate ?>
                
            
        
    




No hace falta explicar mucho más de la vista anterior ya que es una vista normal en KumbiaPHP, esta vista es reutilizable por ejemplo si se quiere pasar a un documento Excel o devolver la vista mediante AJAX.



Enlazar al reporte PDF



Y en donde queramos que esté el enlace al reporte PDF simplemente lo añadimos a la vista deseada, nosotros lo hemos añadio a la página de información de los ejemplos de template.



Archivo: app/views/templates_examples/info.pdf.phtml



Export users list



Y al pulsar el botón visualizaremos el documento PDF como el siguiente:



Visualización del PDF generado con HTML



Descargar código completo



Como siempre, el código completo está disponible para todos en el siguiente repositorio en Github listo para usar: https://github.com/KumbiaPHP/Sandbox/


La entrada Exportar tabla HTML a PDF se publicó primero en KumbiaPHP Framework PHP en español.



Crear PDF usando HTML
HenryStivens — Mon, 06 Aug 2018 10:00:37 +0000
Para crear PDF usando HTML con PHP existen diferentes librerías que nos pueden ayudar a cumplir el objetivo de manera sencilla, esta vez vamos a probar mPDF. mPDF es una librería en PHP la cual permite generar archivos PDF usando HTML(Codificado con UTF-8). Está basada en FPDF y HTML2FPDF, con varias mejoras, fue escrito por Ian Back y lanzado bajo licencia GNU GPL v2.
Instalación de mPDF
El método de instalación oficial de mPDF en PHP es via composer y este es el paquete packagist: mpdf/mpdf.
composer require mpdf/mpdf
Cargando la librería
Como es un ejemplo básico realizaremos la carga de la librería sólo en el controlador que vamos a usar. De la siguiente manera:
Archivo: default/app/controllers/index_controller.php


Primer ejemplo de crear PDF usando HTML
Creamos el método example1() donde sin usar vista o template creamos el «Hola mundo» del uso de la librería con el siguiente código:

Archivo: default/app/controllers/index_controller.php
public function example1()
{
    //Importante: Sin vista y sin tamplate 
    View::select(null, null);
    //Crea una instancia de la clase y le pasa el directorio default/app/temp/ 
    $mpdf = new Mpdf(['tempDir' => APP_PATH . '/temp']);
    //Escribe algo de contenido HTML: 
    $mpdf->WriteHTML('¡Hola KumbiaPHP!');
    //Envía un archivo PDF directamente al navegador $mpdf->Output(); 
}
Dependiendo de la configuración del navegador nos mostrará en su visualizador de PDFs el documento creado. En caso contrario nos mostrará el diálogo para iniciar la descarga.
Ejemplo de crear PDF con HTML
Segundo ejemplo ¡Usaremos vistas!
El primer ejemplo está bien, pero a nosotros nos gusta darle más orden y para mantener la lógica en su lugar. Vamos a crear un modelo llamado HtmlToPdf (Pueden llamarlo como deseen) y es donde a partir de ahora vamos a crear los archivos PDF, pero esta vez llamaremos el contenido de un partial, el cual nos servirá para mantener separado el HTML del PHP. Primero observemos el contenido del partial:
Archivo: default/app/views/_shared/partials/pdf/example2.phtml
¡Hola KumbiaPHP!

Ahora si el método example2() en el modelo:
Archivo: default/app/models/html_to_pdf.php
 APP_PATH . '/temp']); 
        // Escribe algo de contenido HTML: 
        $mpdf->WriteHTML($html); 
        // Envia un archivo PDF directamente al navegador 
        $mpdf->Output(); 
    } 
}

Ahora simplemente en el controlador sin usar vista ni template llamaremos el método example2() de la clase modelo HtmlToPdf
Archivo: default/app/controllers/index_controller.php
public function example2() 
{ 
    //Importante: Sin vista y sin tamplate 
    View::select(null, null); 
    //Llama al ejemplo 2 
    HtmlToPdf::example2(); 
}

El código anterior hace exactamente lo mismo que el primer ejemplo, la diferencia es que esta vez usamos MVC. En el modelo añadimos la lógica para crear el documento pdf a partir de una vista parcial (partial), usamos el controlador para llamar el método implementado en el modelo.
Podemos añadir todo el HTML que deseemos siempre y cuando sea compatible con mPDF, eso nos da juego para añadir tablas, imágenes, enlaces, añadir estilos con css, etc.
Ejemplo 3
Vamos a hacer esta vez que el método del modelo reciba un parámetro $name y se lo pase a la vista parcial (partial) pdf/example3.
public static function example3($name) 
{ 
    // Activa el almacenamiento en búfer de la salida 
    ob_start(); 
    // Carga el contenido del partial pasandole datos 
    View::partial('pdf/example3', '', ['name' => $name, 'date' => date(DATE_ISO8601)]); 
    // Obtiene en $html el contenido del búfer actual y elimina el búfer de salida actual $
    html = ob_get_clean(); 
    // Crea una instancia de la clase y le pasa el directorio temporal 
    $mpdf = new Mpdf(['tempDir' => APP_PATH . '/temp']); 
    // Escribe algo de contenido HTML: 
    $mpdf->WriteHTML($html); 
    // Obliga la descarga del PDF y se personaliza el nombre 
    $mpdf->Output('example3.pdf', \Mpdf\Output\Destination::DOWNLOAD); 
}
Ahora haremos que el partial reciba el valor de las variables y las imprima para que se muestre en el PDF.
Archivo: default/app/views/_shared/partials/pdf/example3.phtml
¡Hola !
 Este documento fue generado el  

Si entramos a la URL: http://localhost:8184/index/example3/Henry nos descargará el PDF con el nombre example3.pdf y veremos algo como la siguiente captura de pantalla:
Ejemplo 3 De HTML a PDF
Estos fueron tres ejemplos básicos para generar PDF usando HTML con PHP.
Segunda Parte de HTML a PDF
Exportar tabla HTML a PDF
Si desean que hagamos un nuevo tutorial con ejemplos avanzados y de la vida real dejen su comentario en la caja de abajo.
Descargar código completo
Como siempre, el código completo del ejemplo para crea documentos PDF con PHP está disponible para todos en el siguiente repositorio en Github listo para usar con Docker: https://github.com/henrystivens/kumbiaphp-mpdf
Nuevos ejemplos de mPDF
Puedes ver un ejemplo del PDF generado más completo funcionando en ejemplo mPDF  y el código PHP de ejemplo controlador y template para usar con cualquier vista de HTML.
La entrada Crear PDF usando HTML se publicó primero en KumbiaPHP Framework PHP en español.



Select anidado o select dependientes
HenryStivens — Fri, 17 Nov 2017 00:58:20 +0000
Con este tutorial vamos a aprender como implementar select anidado o select dependientes usando KumbiaPHP y jquery. Es una lista simple enlazada con tres niveles: Regiones, comunas y ciudades.
Implementando el select anidado
Primero que todo cargamos la librería jquery añadiendo en nuestro template activo la siguiente línea:



La base de datos

CREATE TABLE `ciudad` (
  `id` int(4) NOT NULL AUTO_INCREMENT,
  `comuna_id` int(4) NOT NULL,
  `nombre` varchar(100) NOT NULL,
  PRIMARY KEY (`id`),
  KEY `FK_ciudad__comuna` (`comuna_id`),
  CONSTRAINT `FK_ciudad__comuna` FOREIGN KEY (`comuna_id`) REFERENCES `comuna` (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

INSERT INTO `ciudad` VALUES (1,1,'Primera Ciudad'),(2,2,'Primera Ciudad'),(3,2,'Segunda Ciudad'),(4,3,'Primera Ciudad'),(5,3,'Segunda Ciudad'),(6,3,'Tercera Ciudad');

CREATE TABLE `comuna` (
  `id` int(4) NOT NULL AUTO_INCREMENT,
  `region_id` int(4) NOT NULL,
  `nombre` varchar(100) NOT NULL,
  PRIMARY KEY (`id`),
  KEY `FK_comuna__region` (`region_id`),
  CONSTRAINT `FK_comuna__region` FOREIGN KEY (`region_id`) REFERENCES `region` (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

INSERT INTO `comuna` VALUES (1,1,'Primera Comuna'),(2,1,'Segunda Comuna'),(3,2,'Primera Comuna'),(4,3,'Primera Comuna');

CREATE TABLE `region` (
  `id` int(4) NOT NULL AUTO_INCREMENT,
  `nombre` varchar(100) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

INSERT INTO `region` VALUES (1,'Primera Region'),(2,'Segunda Region'),(3,'Tercera Region');


Los modelos
Vamos a tener tres modelos que se encargaran de la consulta de los datos, heredando como no de la clase ActiveRecord:
Archivo: app/models/region.php

find('order: nombre');
    }
}

Archivo: app/models/comuna.php

find("region_id = $region_id", 'order: nombre');
    }
}

Archivo: app/models/ciudad.php

find("comuna_id = $comuna_id", 'order: nombre');
    }
}

El controlador
Usaremos de ejemplo el controlador UserController aunque no implementaremos la funcionalidad de creación de un usuario para enforcarnos en el select anidado. Tendrá dos funciones auxiliares que nos cargarán los respectivos selects sin template, getComunas() y getCiudades().
Archivo: app/controllers/user_controller.php

region_id = Input::post('region_id');
    }

    public function getCiudades()
    {
        //No es necesario el template
        View::template(null);
        //Carga la variable $comuna_id en la vista
        $this->comuna_id = Input::post('comuna_id');
    }
}

Las vistas
La primera vista es la de crear un usuario, la cual contendrá los tres selects, aunque en principio solo mostrará el primero y unas capas vacias, ya que los siguientes dependen de qué se seleccione y serán cargados mediante ajax:
Archivo: app/views/user/create.phtml
Crear usuario



  
    
      Región
      
    
  
  
    
      Comuna
      
    
  
  
    
      Ciudad
      
    
  




La vista anterior con javascript añade un listener para que cuando el valor del select que contiene las regiones cambie, haga un llamado mediante ajax para obtener el listado de comunas por región y este resultado lo carga en la capa div_comunas.
La siguiente vista cargará el select usando el helper Form::dbSelect() usando el método allByRegion() del modelo Comuna y pasándole como parámetro $region_id.

 Archivo: app/views/user/getComunas.phtml




La vista anterior con javascript añade un listener para que cuando el valor del select que contiene las comunas cambie, haga un llamado mediante ajax para obtener el listado de ciudades por comuna y este resultado lo carga en la capa div_ciudades.
La siguiente vista es similar a getComunas.phtml, lo que hace es cargar todas las ciudades que pertenezcan a una comunidad usando el helper Form::dbSelect() pasandole como parámetros el nombre del modelo ciudad, el método allByComuna() y el parámetro de consulta $comuna_id.
Archivo: app/views/user/getCiudades.phtml
 
Ejecutando el ejemplo
Cuando cargamos la url /user/create veremos algo como lo siguiente, en primera instacia solo va mostrar las regiones:
Muestra el primer select anidado
Lo siguientes dos select se mostraran comforme se vaya seleccionando una región y posteriormente una comuna.
Lista enlazada simple de tres niveles
Descargar código completo
Como siempre, el código completo está disponible para todos en el siguiente repositorio en Github listo para usar con Docker: https://github.com/henrystivens/dependent-select
La entrada Select anidado o select dependientes se publicó primero en KumbiaPHP Framework PHP en español.



Paginación en PHP fácil y rápida
HenryStivens — Fri, 21 Jul 2017 05:01:24 +0000
Con este tutorial mostraremos como realizar la paginación en PHP de un listado de usuarios usando nuestro framework favorito KumbiaPHP. Utilizaremos como base el proyecto anterior, donde mostramos como subir una imagen y asignarla a un usuario, y cambiaremos el listado normal por un listado paginado.
En el controlador
Lo primero es mencionar que el ActiveRecord cuenta con un paginador muy bueno(Ver sección en el manual: Paginando en ActiveRecord), que nos permitirá con una sola línea de código implementar la paginación en php. Vamos al controlador de usuarios y añadimos la función page(…):
Archivo: app/controllers/user_controller.php

public function page(int $page = 1)//validación 'int' con php7
{        
    $this->page = (new User)->paginate("page: $page", 'per_page: 7');
}

El parametro $page tiene un valor por defecto, así que, si no le pasamos ningun valor será igual a 1. En el llamado a la función paginate() el primer parámetro es page, con el cual le indicamos el número de página que deseamos mostrar. El segundo parámetro es per_page, con el cual le indicamos el número de elementos a mostrar por página.

La vista
Creamos un nuevo archivo llamado page.html es una vista similar a index.phtml, con la diferencia que para obtener el arreglo de elementos, ojo esto es muy importante, se accede al atributo items del objeto $page. La otra diferencia es que se hace llamado a un partial el cual nos mostrará el paginador con el número de página actual y los números de páginas disponibles. Si, este partial nos ahorra un montón de trabajo ya que en él está toda la lógica de visualización.
Archivo: app/views/user/page.phtml
Lista de usuarios
 

items) > 0) { ?>
    
        
                        
                
                
                
                
                
            
        
         
            items as $item) { ?> 
                
                    
                    
                    
                    
                    
                 
                    
        
    Nombre Edad Correo Foto Acciones
name ?> age ?> email ?> photo ?> id", 'Editar') ?> | id", 'Actualizar foto') ?>


    No hay ningún registro


 $page)); ?>

Existen otros partials que sirven de paginadores, también puedes crear los tuyos para que se adapten a tu diseño.
Así se ve la paginación en PHP
Lista de usuarios paginados
Si vas a usar otra acción diferente de page() debes pasarle al partial como parámetro la url de la acción, así:
Archivo: app/views/user/page.phtml

 $page, 'url' => 'user/index')); ?>

Descargar código completo
Como siempre, el código completo está disponible para todos en el siguiente repositorio en Github listo para usar con Docker: https://github.com/henrystivens/paginate-php 
La entrada Paginación en PHP fácil y rápida se publicó primero en KumbiaPHP Framework PHP en español.



ScaffoldController: Modificando comportamientos y contenidos
Nelson Rojas — Wed, 12 Apr 2017 13:28:01 +0000
La entrega anterior hablamos acerca del uso de la técnica de Scaffolding para CRUD con KumbiaPHP usando la clase ScaffoldController. Espero que muchos se hayan sorprendido gratamente con la funcionalidad que ciertamente ahorra mucho trabajo rutinario, ya que es altamente flexible.
Para que se entusiasmen, dentro de las posibilidades  tenemos: reescribir métodos y modificar comportamientos en controladores, modificar los archivos de vista, e incluso puedes crear tus propios scaffoldings. Pero bueno, vamos paso a paso.
Manos a la obra con ScaffoldController
Vamos a trabajar en base a supuestos. Supongamos que queremos mostrar el nombre de la categoría padre para aquellas categorías que estén anidadas.

Como se ve en la lista, las categorías relacionadas sólo se ven con su identificador.

Por lo tanto, vamos a modificar la fuente de datos que pasamos a la vista Index para que ésta pueda presentar los contenidos respectivos.
En el modelo
Lo que vamos a hacer es crear un método que cumpla con lo que queremos lograr: mostrar el contenido de la tabla de categorías incluyendo el nombre de la categoría padre en aquellas categorías que heredan de otra. De este modo tendremos una modificación como la siguiente:
Archivo: models/categorias.php


class Categorias extends ActiveRecord 
{

    function getCategorias($page = 1) 
    {
        return $this->paginate(
            'columns: categorias.id, categorias.nombre, cat.nombre as categorias_id, categorias.creada_at, categorias.actualizada_in', 
            'join: left outer join categorias cat on categorias.categorias_id = cat.id',
            "page: $page", 'order: categorias.id desc');
    }

}
En el controlador
El segundo cambio lo haremos desde el controlador, para cargar los cambios que hemos hecho en el modelo. Lo que reemplazaremos (porque es una sobre escritura de index en ScaffoldController) será la función index tal como se muestra a continuación.
Archivo: controllers/categorias_controller.php

class CategoriasController extends ScaffoldController
{
    public $model = 'Categorias';

    public function index($page=1)
    {
        $this->data = (new Categorias)->getCategorias($page);
    }
 
}

Ahora se ve así
Con esto lograremos que el listado cumpla que el requerimiento solicitado.

¿Por qué funciona?
Como puede verse, con cambios mínimos hemos logrado adecuar la presentación de la vista index sin actualizar su archivo. Lo que hemos hecho principalmente es un reemplazo dentro de la metadata de ActiveRecord. Scaffolding espera contar con todos los atributos de la tabla de categorías (id, nombre, categorias_id, creada_at, actualizada_in). Nosotros hemos modificado la salida cambiando categorias_id por nombre desde categorias (nombre as categorias_id). Así hemos logrado que el pintador de la vista index haga su tarea sin enterarse del reemplazo que hemos hecho a nivel de modelo.
Bueno, eso es todo por esta semana. En la siguiente entrega veremos cómo modificar una vista particular para hacerla parecer según nuestros requerimientos. (ver parte 3)
Últimas recomendaciones
Recuerden que pueden revisar el código desde: https://github.com/nelsonrojas/Scaffold-KumbiaPHP
No olvides visitarnos en http://slack.kumbiaphp.com/ para contarnos cómo te va usando KumbiaPHP. Si necesitas apoyo procuraremos estar atentos. Además, si te gusta lo que escribimos compártelo ya mismo con tus amigos y colegas.
Saludos y larga vida a KumbiaPHP!
Con cariño desde Talca, Chile: @nelsonrojas
Ps: Si te perdiste lo que escribimos la semana pasada, puedes leerlo aquí: https://www.kumbiaphp.com/blog/2017/04/03/scaffolding-para-crud-abm-sencillos-y-no-tanto-primera-parte/
Si quieres ver lo que sigue: ScaffoldController: Modificando vistas
La entrada ScaffoldController: Modificando comportamientos y contenidos se publicó primero en KumbiaPHP Framework PHP en español.



Scaffolding para CRUD (ABM) sencillos (y no tanto) – primera parte
Nelson Rojas — Mon, 03 Apr 2017 10:39:38 +0000
¿Qué es Scaffolding?
Cuando comenzó el fenómeno de los frameworks de desarrollo web, una de sus banderas de lucha estuvo de la mano de los scaffoldings (andamios).
Un scaffold es en sí una técnica que proveen muchos frameworks, con la que podrás tener un gestor de datos para una tabla particular escribiendo una cantidad mínima de código (en KumbiaPHP bastan 7 líneas de código – excluyendo 2 líneas de encabezado php – ).
En mis primeros años de kumbiero comencé creando un controlador para las acciones clásicas de CRUD (Create, Read, Update y Delete), un modelo para apuntar la tabla de la base de datos y al menos 3 archivos de vista (index, agregar y editar).
Para hacer el CRUD de otra tabla copiaba el controlador inicial en el nuevo, luego editaba todo lo que correspondía, y lo mismo hacía para el modelo y las vistas.
Como verán es un trabajo arduo, pero no es tanto trabajo… a menos que tengas más de 10 tablas.
Si pueden hacer el ejercicio de mirar el bosque desde lejos, casi todos los CRUDs creados tienen las mismas acciones, y usan las mismas vistas (con sus leves diferencias).
La iluminación
Fue entonces que un día de IRC (el chat que usábamos antes), los colegas del core de KumbiaPHP me presentaron a ScaffoldController.
Es un amigo silencioso, puesto que está alojado en default/app/libs, pero además es un amigo confiable, pues hereda de AdminController (eso quiere decir que si damos cierta habilidad de autenticación al AdminController, los controllers que hagamos usando ScaffoldController también estarán asegurados).
Configuración inicial
Si este es un proyecto que ha iniciado desde cero, deberá configurar el acceso a la base de datos antes de continuar.
Para eso usaremos el archivo default/app/config/database.ini. En él se definen los entornos de datos que usará nuestra aplicación, los que normalmente son: development (desarrollo) y production (producción)

Los parámetros de configuración que debemos revisar son:

host: Nombre de red o dirección ip del equipo en el cual está instalada la base de datos.
username: usuario de la base de datos.
password: contraseña del usuario de la base de datos.
name: nombre de la base de datos.
type: el tipo de base de datos que usará el proyecto, como mysql, pgsql, oracle.

Para indicarle al proyecto que debe usar uno u otro entorno de base de datos, será necesario modificar el archivo de configuración default/app/config/config.php. De forma predeterminada la configuración del entorno de base de datos es ‘default’, pero lo dejaremos inicialmente como ‘development’.

Lista la configuración, sigamos con la acción.
De la teoría a la acción
Bueno, mucho texto y poca acción (o como versa el dicho “mucho ruido y pocas nueces”).
En nuestro primer ejemplo usaremos la clásica tabla de categorías, con la siguiente estructura:

CREATE TABLE categorias (
 id int(11) NOT NULL AUTO_INCREMENT,
 nombre varchar(200) NOT NULL UNIQUE,
 categorias_id int(11),
 creada_at timestamp,
 actualizada_in timestamp,
 PRIMARY KEY (`id`)
);
Ahora crearemos un modelo llamado Categorias.
Archivo: models/categorias.php


class Categorias extends ActiveRecord
{
}
Y finalmente (sí, finalmente) añadiremos el controlador CategoriasController.
Archivo: controllers/categoria_controller.php


class CategoriasController extends ScaffoldController
{
 public $model = 'Categorias';
}

¡Y hemos terminado!
Así de sencillo ya tenemos nuestro primer CRUD sin dolor.


Tendremos inicialmente las acciones para index, agregar, editar, ver y eliminar, y sólo hemos escrito 7 líneas.
Personalizando las vistas
Y ahora, ¿quién podrá defendernos de la hoja de estilo predeterminada? ¡Excelente pregunta!
Bueno, los muchachos del core ya tuvieron eso previsto para nosotros. Resulta que puedes crear tus propias vistas para usarlas con tus controladores de Scaffold. Basta copiar el contenido de app/views/_shared/scaffold/kumbia en una nueva versión de vistas para tus controladores.

Supongamos que nos piden usar skeleton. Por lo tanto ahora tendremos una carpeta llamada app/views/_shared/scaffolds/skeleton, con los mismos tres archivos de vistas: crear, index, ver.
Y ¿cómo le decimos a nuestros controladores que usen nuestro nuevo conjunto de vistas?

Sencillo:


class CategoriasController extends ScaffoldController
{
 public $model = 'Categorias';
 public $scaffold = 'skeleton';
}
El resultado final
Si miramos el resultado tendremos algo como lo que se ve en las siguientes imágenes:
Vista usando skeleton

Formulario usando skeleton

Así de fácil logramos crear nuestro primer CRUD con 8 líneas de código y con nuestro css preferido (o requerido).
Si quieres ver lo que sigue, mira en los enlaces que están a continuación:
Parte 2: ScaffoldController: Modificando comportamientos y contenidos
Parte 3:  ScaffoldController: Modificando vistas
Descarga el ejemplo completo
Pueden descargar el código del proyecto desde el siguiente repositorio de Github
Si buscan el script de la tabla de categorías pueden encontrarlo dentro de app/config/sql
¡Larga vida a KumbiaPHP!
La entrada Scaffolding para CRUD (ABM) sencillos (y no tanto) – primera parte se publicó primero en KumbiaPHP Framework PHP en español.