¿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:

<?php

return [
    'api_key' => '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:

<?php

use \OpenAI\Client;

/**
 * OpenAI Service Model
 */
class OpenAiModel
{
    /**
     * @var OpenAiModel|null Instancia única de la clase
     */
    private static ?OpenAiModel $instance;

    /**
     * @var Client El cliente OpenAI
     */
    private Client $client;

    /**
     * @var array Configuración de OpenAI
     */
    private array $config;

    /**
     * Constructor para otras config
     *
     * @param array Configuración (opcional)
     */
    public function __construct(?array $config = null)
    {
        $this->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

<?php

class ChatbotController extends AppController
{
    /**
     * Muestra el chatbot
     */
    public function index()
    {
    }

    /**
     * Endpoint para manejar mensajes del chatbot
     */
    public function message()
    {
        View::select(null, 'json');

        $message = Input::post('message');

        $this->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:

<section id="aibot">
    <h1>Chatbot Inteligente con PHP y KumbiaPHP</h1>

    <div id="chatResponse">
        <p>
            <b>Kumbita:</b> Hola, me llamo Kumbita. ¿Qué quieres saber hoy?
        </p>
    </div>

    <?= Form::open('', 'POST', 'id="chatbot"') ?>
    <?= Form::text('message', 'placeholder="Escribe tu pregunta" autofocus') ?>
    <?= Form::submit('Enviar', 'class="btn btn-primary"') ?>
    <?= Form::close() ?>
</section>

<script>
    document.getElementById("chatbot").addEventListener("submit",
        function(event) {
            event.preventDefault();
            sendMessage();
        });

    const messageEl = document.getElementById('message');
    const chatResponse = document.getElementById('chatResponse');
    const btnSubmit = document.querySelector('#chatbot [type="submit"]');
    const speech = 'speechSynthesis' in window ? new SpeechSynthesisUtterance() : null;
    const apiError = "Lo siento, parece que hay un error al conectar a la API";

    speak("Hola, me llamo Kumbita. ¿Qué quieres saber hoy?", "es");

    function sendMessage() {
        const message = messageEl.value;
        if(message.trim() === '') return;
        btnSubmit.disabled = true;
        messageEl.disabled = true;
        chatResponse.innerHTML += `<p><b>Tu:</b> ${message}</p><div id="loading"></div>`;
        chatResponse.scrollTop = chatResponse.scrollHeight;

        fetch('/chatbot/message', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/x-www-form-urlencoded',
                    'Accept': 'application/json'
                },
                body: 'message=' + encodeURIComponent(message)
            })
            .then(response => response.json())
            .then(data => {
                response(data.reply ?? "");
            })
            .catch(error => {
                console.log(error);
                response(apiError);
            })
            .finally(() => {
                btnSubmit.disabled = false;
                messageEl.disabled = false;
                messageEl.value = '';
                messageEl.focus();
            });
    }

    function response(message) {
        speak(message);
        document.getElementById('loading').remove();
        chatResponse.innerHTML += `<p><b>Kumbita:</b> ${message}</p>`;
        chatResponse.scrollTop = chatResponse.scrollHeight;
    }

    function speak(text, lang = navigator.language) {
        if(!speech) return;
        speech.lang = lang
        speech.text = text
        window.speechSynthesis.speak(speech)
    }
</script>

<style>
    #aibot {
        max-width: 500px;
        margin: 0 auto;

        & h1 {
            text-align: center;
        }

        & #chatbot {
            display: flex;
            margin-top: 1em;
        }

        & #message {
            flex: 1;
            border-radius: 2rem 0 0 2rem;
            padding: 0.5em 1em;
            box-shadow: none;

            &:focus {
                outline: none;
            }
        }

        & [type="submit"] {
            flex: 0;
            border-radius: 0 2rem 2rem 0;
            box-shadow: none;
            
            &:disabled {
                opacity: 0.5;
            }
        }

        & #chatResponse {
            margin: 20px auto 0;
            min-height: 60px;
            max-height: 400px;
            background: #f5f5f5;
            border-radius: 6px;
            padding: 1em;
            box-shadow: 1px 1px 5px #eee;
            overflow-y: auto;
            display: flex;
            flex-direction: column;

            & p {
                color: #333;
            }
        }
    }
    #loading {
        width: 12px;
        height: 12px;
        border-radius: 50%;
        display: block;
        margin:15px auto;
        position: relative;
        color: #9ab8ef;
        box-sizing: border-box;
        animation: animloader 1s linear infinite alternate;
    }

    @keyframes animloader {
        0% {box-shadow: -38px -6px, -14px 6px,  14px -6px;}
        33% {box-shadow: -38px 6px, -14px -6px,  14px 6px;}
        66% {box-shadow: -38px -6px, -14px 6px, 14px -6px;}
        100% {box-shadow: -38px 6px, -14px -6px, 14px 6px;}
    }
</style>

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.

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:

<?php
/**
 * MeiliSearch configuration file.
 *
 * This file contains the configuration settings for connecting to MeiliSearch.
 */
return [
    'host' => '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:

<?php

use Meilisearch\Client;

/**
 * Trait MeilisearchSearchableTrait
 */
trait MeilisearchSearchableTrait
{
    /**
     * MeiliSearch client instance.
     */
    protected static ?Client $_meiliClient = null;

    /**
     * Retrieves the MeiliSearch client instance.
     */
    protected static function getMeiliClient(): Client
    {
        if (null !== self::$_meiliClient) {
            return self::$_meiliClient;
        }

        $config = \Config::read('meilisearch');
        if (!$config || !is_array($config)) {
            throw new \RuntimeException('MeiliSearch configuration not found in config file.');
        }
        $host   = $config['host'] ?? 'http://localhost:7700';
        $apiKey = $config['api_key'] ?? '';

        return self::$_meiliClient = new Client($host, $apiKey);
    }

    /**
     * Returns the index name. By default it returns the table name provided by the model.
     */
    protected static function searchableAs(): string
    {
        return static::getTable();
    }

    /**
     * Converts the model instance to an array for indexing.
     */
    abstract protected function toSearchArray(): array;

    /**
     * Callback executed after a model is created.
     * The new record is automatically added to the MeiliSearch index.
     */
    protected function _afterCreate(): void
    {
        self::getMeiliClient()
            ->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

<?php

use Kumbia\ActiveRecord\LiteRecord;

class Product extends LiteRecord
{
    use MeilisearchSearchableTrait;

    protected static $table = 'products';

    protected function toSearchArray(): array
    {
        return [
            'id' => $this->id,
            'name' => $this->name,
            'description' => $this->description,
            'price' => $this->price,
        ];
    }
}

Ejemplo con Modelo Article

<?php

use Kumbia\ActiveRecord\LiteRecord;

class Article extends LiteRecord
{
    use MeilisearchSearchableTrait;

    protected static $table = 'articles';

    protected function toSearchArray(): array
    {
        return [
            'id' => $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

<h1>Buscar productos</h1>

<?php View::content(); ?>

<?= Form::open(); ?>
    <?= Form::text('query', 'placeholder="Buscar..."') ?>
    <?= Form::submit('Buscar') ?>
<?= Form::close(); ?>

<?php if (empty($results) && Input::post('query')): ?>
    <p>No se encontraron resultados.</p>
    <?php return 1 ?>
<?php endif; ?>

<h2>Resultados</h2>
<ul>
    <?php foreach ($results as $product): ?>
        <li>
            <strong><?= h($product['name']) ?></strong><br>
            <?= h($product['description']) ?><br>
            Precio: $<?= h($product['price']) ?>
        </li>
    <?php endforeach; ?>
</ul>

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.

Una parte importante del trabajo dentro de un Framework MVC es el buen uso de los Modelos. 

El modelo es responsable de mantener el estado de la aplicación. A veces este estado es transitorio, y dura sólo un par de interacciones con el usuario. Otras veces el estado es permanente y se almacena fuera de la aplicación, a menudo en una base de datos.

Un modelo es algo más que datos; impone todas las reglas de negocio que se aplican a esos datos. Por ejemplo, si un descuento no debe aplicarse a los pedidos de menos de de 20 euros, el modelo aplicará la restricción. Esto tiene sentido; al poner la implementación de estas reglas de negocio en el modelo, nos aseguramos de que nada más en la aplicación puede hacer que nuestros datos no sean válidos. El modelo actúa como tanto un guardián como un almacén de datos.

Otra definición para el modelo es la siguiente: es el componente central del patrón (MVC). Es la estructura de datos dinámica de la aplicación, independiente de la interfaz de usuario. Gestiona directamente los datos, la lógica y las reglas de la aplicación.

En muchos casos, especialmente cuando uno comienza a trabajar en MVC, se cree que los modelos son únicamente para la gestión de la persistencia y la consulta de los datos de una base de datos (o de un repositorio)

Fundamentos

Antes de ahondar en los ejemplos y en los errores clásicos, nos gustaría mostrarte una imagen que puede ser de ayuda respecto de la forma en la que deberíamos construir nuestras aplicaciones usando el patrón descrito por Trygve Reenskaug (MVC)

La imagen, que es gentileza del Framework CakePHP, nos indica que una aplicación mal diseñada (Bad cake) tiene mucho código en los controladores y poco en las vistas y modelos. En la práctica, los controladores deberían servirnos principalmente para gestionar el Routing (las urls), interactuar con los modelos y despachar las vistas. En contraposición, una buena implementación (Good cake), debería contener más código en los modelos y menos en las vistas y controladores.

Volvamos un poco a lo que se mencionaba sobre el problema de los recién iniciados en MVC. Si bien es común que un modelo gestione datos de una base de datos, también sirve para gestionar «cosas» que no tienen relación con ello. Un ejemplo puede ser un modelo para un carro de compras. Es completamente factible llevar a cabo esta tarea sin persistencia en el DBMS (Database Management System). Bastaría con hacerlo con el objeto de sesión. Por otro lado, un modelo también podría encargarse de los pagos electrónicos, y luego apoyarse de otro que persista datos. Un modelo podría estar dedicado a la realización de cálculos específicos, otro del envío de notificaciones (SMS, Whatsapp, e-mail, etc), otro de la ejecución de tareas por shell dentro del servidor, y así sucesivamente.

¿Qué es lo más común?

Que las personas definan un modelo heredando de la clase del ORM (Object Relational Mapping) y, por ejemplo, en el caso de las notificaciones o el carro de compras, bastaría con que se utilizara una clase simple.

Vale, que aún no hay ejemplos porque nos quedan algunos fundamentos que debemos considerar.

DRY

Para muchos desconocido por sus siglas, pero viene del inglés Don’t Repeat Yourself. En buen castellano sería «No te repitas». ¿Qué significa esto? Significa que debemos gestionar cada «trozo de código» a su labor respectiva, en un único lugar. ¿Y qué tiene de malo copiar y pegar código? Cuando uno tiene mucho código repetido se rompe el principio DRY.

La repetición puede ser principalmente por desconocimiento de las herramientas que provee el Framework, o la clase de la que uno hereda. Por lo tanto, haz tu tarea de estudiante: revisa los métodos, la documentación y luego ponte manos a la obra para que no repitas cosas que ya están implementadas (lo que comúnmente llamamos reinventar la rueda)

Una vez que no tengas ruedas repetidas, verás que realizar modificaciones será una tarea sencilla, evitando así la fragilidad del código.

OOP

En términos de Orientación a Objetos, muchas veces no tenemos tan clara la diferencia entre el uso de la herencia, métodos estáticos y métodos dinámicos. Este tipo de temas los veremos en los ejemplos.

El ORM

Debemos familiarizarnos con la librería que gestiona la persistencia y las consultas al motor de bases de datos, en especial sus métodos, propiedades y los callbacks. En esto último quisiera detenerme un momento. Los callbacks son la analogía a lo que en un motor de base de datos se conoce como triggers (disparadores). Existen diferentes tipos de triggers, pero en generar se clasifican en los que se ejecutan antes de una acción y los que lo hacen después (before y after respectivamente)

El nuevo LiteRecord implementa callbacks para las acciones de creación (_beforeCreate, _afterCreate), para actualización (_beforeUpdate, _afterUpdate) y para guardar (_beforeSave, _afterSave)

En palabras simples, si el modelo encuentra un método _beforeAlgo, ejecutará dicha función antes de que se ejecute el método «Algo» (asumiendo que «Algo» puede ser Create, Save, Update). Por otro lado un _afterAlgo, se ejecutará luego que la función «Algo» haya finalizado.

Estos temas también los iremos tratando con casos cotidianos. Puedes checar su documentación en este enlace.

Traits 

Desde la versión de PHP 5.4 se implementan los Traits (rasgos, características) Es una buena estrategia para continuar con el principio DRY. De pronto tienes propiedades o métodos que son compartidos entre diferentes clases. Puedes extraer esos métodos en un trait y luego indicar que la clase implementa dichos «rasgos». Así tendrás un único lugar para ellos y finalmente, si hay menos código «innecesario o repetitivo», habrá menos errores y será más fácil de hacer mantención/corrección del mismo.

La entrada Cómo crear modelos de forma correcta se publicó primero en KumbiaPHP Framework PHP en español.

Vscode, Google Chrome y Firefox con livereload

Extensión LiveReload para Visual Studio Code: https://marketplace.visualstudio.com/items?itemName=ziishaned.livereload

Extensión LiveReload++ para Google Chrome: https://chrome.google.com/webstore/detail/livereload++/ciehpookapcdlakedibajeccomagbfab

Extensión LiveReload para Firefox: https://addons.mozilla.org/es/firefox/addon/livereload-web-extension/

La entrada Live Reload en PHP se publicó primero en KumbiaPHP Framework PHP en español.

La entrada Compartir el core para diferentes aplicaciones se publicó primero en KumbiaPHP Framework PHP en español.

Instalación de KumbiaPHP usando XAMPP en Windows

El segundo video trata sobre la…

Configuración de virtual host en Apache para usarlo con KumbiaPHP

La entrada Instalación de XAMPP y configuración de VirtualHost se publicó primero en KumbiaPHP Framework PHP en español.

Tendremos un servidor local de PHP perfecto para desarrollo, sin usar WAMP o XAMPP server.

Antes de comenzar, te dejamos un enlace donde se explican las implicancias del WSL (Windows Subsystem for Linux) https://es.wikipedia.org/wiki/Windows_Subsystem_for_Linux

Vamos con los requisitos. Lo primero que necesitamos es habilitar la caracterísca de Subsistema Linux desde Windows.

Instalar WSL en Windows 10

Para ello hacemos clic en inicio y escribimos <em>Características de Windows</em> (en mi caso se verá diferente porque llevo una versión de Windows en inglés)

Luego buscaremos al final de la lista el Subsistema Linux para Windows (ver imagen siguiente)

Lo seleccionamos haciendo clic en la casilla de la izquierda, y finalizamos picando en el botón OK para que los cambios sean aplicados.

Tendremos que reiniciar para que la configuración se vea actualizada.

Seleccionar la distribución de Linux en la Tienda de Microsoft

Una vez hecho eso, iniciaremos a la aplicación Tienda de Microsoft (Microsoft Store) y usando su buscador, escribiremos la palabra linux.

La lista de opciones es variada pues se cuenta con Ubuntu, Kali, Debian, OpenSuse, entre otros. Para cuestiones de demostración he seleccionado la opción Debian (aunque en otra máquina lo he probado con Ubuntu 18.04).

Bastará con seleccionar la opción de vuestro gusto, y luego presionar el botón Obtener (Get en mi caso)

Puede que el instalador te pregunte, si quieres mantener sincronizadas tus máquinas de acuerdo a tu cuenta. En mi caso, prefiero que sólo sea instalado en esta máquina, sin importar la sincronización posterior (para ello te requerirá iniciar sesión con una cuenta de Windows Live – Hotmail, Outlook u otra)

En este diálogo he seleccionado «No, gracias». Luego de la respuesta, ha comenzado el proceso de instalación.

Crear usuario y contraseña de la consola de linux

Cuando la configuración de la consola linux haya finalizado, nos pedirá crear un usuario con nombre y contraseña.

Noten que el nombre de usuario de la consola, no tiene por qué coincidir con el nombre de usuario de la máquina de Windows. Una vez creado el usuario habremos finalizado la instalación de la consola de Linux!

Entonces ya tenemos nuestra estación Linux completamente funcional. 

Actualizar paquetes de Linux

En los derivados de Debian (como Ubuntu y Kali) les recomiendo comenzar ejecutando el comando:

<span class="token function">sudo</span> <span class="token function">apt-get</span> update

Con ello cargarás los repositorios de paquetes que podrás usar posteriormente.

Instalar PHP y MariaDB (MySql) en la consola Linux de Windows

Para usar Debian y derivados, con los requerimientos mínimos de desarrollo kumbiero necesitamos hacer la siguiente instalación

<span class="token function">sudo</span> <span class="token function">apt-get</span> <span class="token function">install</span> php php-cli php-mysql mariadb-server php-mbstring <span class="token function">git</span> <span class="token function">wget</span> unzip

Instalar KumbiaPHP framework

Una vez que hemos finalizado la instalación, podemos hacer una prueba descargando la versión de KumbiaPHP desde la página principal del proyecto

Lo hacemos desde el icono de descarga para el formato tar. Hacemos clic con el botón secundario (normalmente el derecho) y copiamos el link desde el botón Copiar enlace (Copy link)

Luego desde la consola escribimos wget y pegamos lo que tenemos en el portapaleles. Deberíamos lograr una línea de ejecución como la siguiente:

<span class="token function">wget</span> https://github.com/KumbiaPHP/KumbiaPHP/archive/v1.0.0.tar.gz

Descomprimimos la descarga:

<span class="token function">tar</span> xvfz v1.0.0.tar.gz

Y renombramos la carpeta resultante con un nombre que tenga relación con el trabajo que llevaremos a cabo (usando el comando mv)

Finalizamos la prueba de instalación entrando en la carpeta que hemos creado hasta llegar a <strong>default/app</strong>

Servidor PHP local

Sin instalar Apache o Nginx,  escribiendo el comando:

bin/phpserver

Windows nos preguntará, si acaso queremos permitir conexiones desde redes internas o desde fuera de la red. Para efectos de prueba he seleccionado ambas opciones y he presionado el botón «Permitir acceso» (Allow access)

Entonces, nuestra aplicación recién instalada de KumbiaPHP estará disponible desde la dirección http://0.0.0.0:8001. En caso que no resulte también puedes invocarla usando la url de http://localhost:8001, o usando http://127.0.0.1:8001, o incluso la dirección ip interna de tu máquina como por ejemplo http://192.168.1.101:8001. Esta última opción nos servirá para hacer pruebas desde otros dispositivos conectados a la misma red (por ejemplo desde un tablet, o un móvil)

Permisos de la base de datos (Mysql, MariaDB, Postresql, otros)

Un dato final, es si usamos MySQL o MariaDB o Postgresql, Windows nos preguntará si queremos dar acceso a dichos servicios, tal como ha hecho cuando hemos lanzado <strong>bin/phpserver</strong>. En dicho caso sólo les recomiendo habilitar el uso en el equipo y la red local. No para el exterior. Aunque esta es una decisión que debe tomar cada uno.

¿Y qué hemos ganado con lanzar KumbiaPHP con el comando bin/phpserver?

Pues la ventana en la que lo hemos lanzado, se ha convertido en una ventana de log de utilización, por la que veremos cada una de las acciones que realice el framework mientras estamos trabajando con él

Y lo más importante, también veremos los errores al instante, para depurar más rápidamente nuestas aplicaciones.

Y hasta aquí nuestra publicación :-)

Esperamos que les sea de utilidad y que con ello tengan nuevas opciones de disfrutar programando con el framework más rápido del oeste!

Saludos a todos nuestros colegas kumbieros!

Post data: si eres nuevo por aquí te recomendamos ver algunos de nuestros posts para los recién llegados:

KumbiaPHP essentials

Scaffolding con KumbiaPHP

Dicho esto,

Larga vida a KumbiaPHP!

La entrada Servidor PHP desde la consola Linux de Windows se publicó primero en KumbiaPHP Framework PHP en español.

[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

<?php

use Mpdf\Mpdf;

/* Defaults */

// fileName
$fileName = $filename ?? "Reporte-de-$controller_name";

// Title
$title = $title ?? "Reporte de $controller_name";

// CSS
$css = $css ?? 'css/pdf.css';

// Destination I show in browser  D download
$destination = isset($download) && $download ? 'D' : 'I';

//Activa el almacenamiento en búfer de la salida
ob_start();

?>
<!DOCTYPE html>
<html lang="en">

<head>
    <title><?= $title ?></title>
    <link rel="stylesheet" type="text/css" href="<?= $css ?>">
    <meta name="author" content="KumbiaPHP framework">
    <meta name="description" content="PDF output example with KumbiaPHP framework">
    <meta name="keywords" content="kumbiaphp, php, pdf, mpdf, examples">

<body>
    <htmlpageheader name="myHeader1">
        <section id="page-header">
            <a href="https://www.kumbiaphp.com"><img src="img/kumbiaphp.svg" alt="Logo KumbiaPHP"></a>
            <p>Powered by</p>
        </section>
    </htmlpageheader>

    <?php View::content() ?>

    <htmlpagefooter name="myFooter1">
        <section id="page-footer">
            <div id="printed-date">{DATE d/m/Y}</div>
            <div id="page-number">{PAGENO}/{nbpg}</div>
        </section>
    </htmlpagefooter>
</body>

</html>
<?php
$html = ob_get_clean();
ob_clean();

// Crea una instancia de la clase y le pasa el directorio temporal
$mpdf = new Mpdf([
    'tempDir' => APP_PATH . 'temp/mpdf',
    'format' => 'A4',
    'title2annots' => true,  // convert headers <hx> 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 <body> 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.

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.

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 

<?php if (!count($data)) : ?>
    <h2>No hay ningún registro</h2> 
<?php else : ?>
    <table class="report">
    <caption class="caption"><?= $title ?></caption>
        <thead>
            <tr>
                <th scope="col">First Name</th>
                <th scope="col">Last Name</th>
                <th scope="col">Email</th>
                <th scope="col">Birthdate</th>
            </tr>
        </thead>
        <tbody> 
            <?php foreach ($data as $item) : ?>
                <tr>
                    <td><?= $item->first_name ?></td>
                    <td><?= $item->last_name ?></td>
                    <td><?= $item->email ?></td>
                    <td><?= $item->birthdate ?></td>
                </tr>
            <?php endforeach ?>
        </tbody>
    </table>
<?php endif ?>

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

<a href="/templates-examples/pdf" target="_blank">Export users list</a>

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

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.

Va especialmente dedicado a nuestros colegas que alguna vez han llegado al chat grupal con la frase:

Es que no funciona en producción

La primera pregunta que debemos resolver es:

¿Por qué no funciona?

A continuación presentamos una lista de los temas más comunes que deberíamos tener en cuenta para resolver la pregunta que impulsa este artículo.

1. ¿El servidor apache está ejecutándose?
2. ¿El mod rewrite está activo?
3. ¿El mod rewrite está configurado para nuestra ruta en el servidor?
4. ¿PHP está instalado y configurado?
5. ¿El servidor de bases de datos está activo?
6. ¿La cuenta en el servidor de bases de datos es la que corresponde en la configuración de nuestra aplicación?
7. ¿Hemos trasladado todos los cambios desde el servidor de bases de datos de desarrollo hacia el servidor de producción?
8. ¿Nuestra aplicación tiene los permisos bien configurados?
9. ¿Hemos copiado completamente la aplicación desde el servidor de desarrollo (incluidos todos los archivos .htaccess)?
10. ¿Hemos configurado correctamente la constante PUBLIC_PATH?
11. ¿Podemos usar PATH_INFO o necesitamos cambiar la estrategia de generación de URL?
12. Si estamos completamente a ciegas, ¿hemos activado la visualización de errores?
13. El sitio presenta un error ERR_TOO_MANY_REDIRECTS al cargarlo.

NOTA: Si es la primera vez que haces un paso a producción (deployment) a un servidor dedicado o en un hosting compartido, te recomendamos leer los siguientes artículos que hemos alojado en nuestra wiki.

• Pasar a producción: http://wiki.kumbiaphp.com/Pasar_a_produccion
• Kumbia en servidor con CPanel: http://wiki.kumbiaphp.com/KumbiaPHP_en_servidor_con_CPanel

Continuemos entonces con el checklist:

¿El servidor Apache está ejecutándose?

Nuestra primera tarea será revisar que el servicio de Apache se encuentre activo y en el puerto necesario. Asumiendo que la tarea de despliegue (deployment) se realiza en un servidor linux, podemos revisar si el servicio está activo y si acaso el puerto está escuchando.

Revisemos el servicio web con los siguientes comandos:

ps -fea | grep -i http
ps -fea | grep -i apache

Si encontramos resultados, es decir, al menos 2 líneas se visualizan como salida a nuestro comando*, es que el servicio está activo.

*el comando ps es “process status” o estado del proceso. Las opciones -fea son para indicar que nos liste los procesos de nuestro usuario como del resto, así como algo de información relacionada con el proceso. Para realizar el filtro entre todos los procesos hemos usado un pipe | o tubería para enviar el resultado del comando ps al comando grep que buscará en la lista si acaso existe algo que contenga el texto “http”, o algo que contenga “apache”. Se usa con -i para que no discrimine entre mayúsculas y minúsculas o alguna combinación de ellas. Para más ayuda sobre estos comando les recomendamos usar el comando man ps o también pueden usar man grep.

NOTA: si usan el comando man (manual) para ps o para grep lo más seguro es que se encuentren con el editor vi. Para salir de él bastará con presionar Esc (escape), luego : (dos puntos) y luego q (la letra q para quit).

Revisemos ahora que el servicio está activo y escuchando peticiones.

Para eso nos bastará en primera instancia abrir un navegador y apuntarlo a la dirección de nuestro servidor. Si tenemos respuesta de la página de bienvenida del servicio (apache) ya tendremos este tema resuelto.

Ahora, si tenemos acceso por consola, podemos probar usando el comando

netstat -av | grep http

En mi caso, uso apache y su nombre de servicio es http. En otros Sistemas Operativos o paquetes de software que incluyen Apache, el servicio web puede encontrarse como apache o apache2.

¿El mod rewrite está activado?

Esta pregunta no es difícil de responder si usamos un pequeño archivo PHP al que llamaremos info.php. En él escribiremos <?php phpinfo(); ?> y luego lo abriremos desde el navegador (normalmente http://localhost/info.php)

Así aprovecharemos para revisar que PHP está activo y en la versión del mismo.

Una vez cargue la página de información de php buscaremos (en general con Ctrl + F o Cmd + F) la palabra rewrite. Deberíamos encontrarla en la sección apache2handlers, en la fila Loaded Modules.

Como se aprecia en la imagen anterior también está activo mod_php7 :-)

En caso que no lo encontremos, o que el archivo info.php no nos dé información, bastará con hacer la activación desde la consola (en el caso de tener servidor con shell activa). Vamos a asumir que usamos un servidor con un sistema operativo derivado de debian (ubuntu o similar). Entonces escribiremos en la consola como root

a2enmod rewrite

Y luego reiniciamos el servicio de apache (también como root)

service apache2 restart

Con esto ya deberíamos tener activado el módulo de sobrescritura de url.

¿El mod rewrite está configurado para nuestra ruta en el servidor?

Bueno, no basta con activar el mod rewrite, hay que configurarlo también.

Nota del autor: esto es lo que normalmente hago en mi configuración de apache. 
No sé si es lo más recomendado. Los comentarios son bienvenidos :)

Para realizar este cambio iremos al archivo de configuración de apache (generalmente alojado en /etc/apache2/apache2.conf)

Lo editaremos y buscaremos una sección llamada Directory.

Buscaremos aquella cuya línea sea Directory /var/www y cambiaremos la opción AllowOverride None por AllowOverride All. Guardaremos la configuración y procederemos a reiniciar el servicio apache.

En las imágenes siguientes se ve el antes y el después de la configuración.

Con estos pasos el mod rewrite estará activo y configurado.

¿PHP está instalado y configurado?

Si hemos llevado a cabo los pasos anteriores para saber si el mod rewrite estaba activo, y lo hemos encontrado en el archivo info.php, entonces es que tenemos PHP bien instalado.

En caso que no hayamos logrado entonces deberemos instalar el módulo PHP en nuestro servidor.

Para hacer esta tarea usaremos nuevamente la consola (shell) para hacer la instalación.

La instalación varía un poco entre distribuciones de servidor, pero haremos la instalación pensando en algún derivado de debian (como si fuéramos root)

apt-get install libapache2-mod-php php

Una vez que la instalación haya finalizado necesitaremos reiniciar el servicio web (como root)

service apache2 restart

Si tenemos aún el archivo info.php, pues lo abriremos desde el navegador (normalmente http://localhost/info.php)

Si logramos ver el resultado de nuestro archivo, entonces ya tendremos claro que PHP está activo en nuestro servidor.

¿El servidor de bases de datos está activo?

Si usamos MySQL o MariaDB bastará con intentar hacer login con la cuenta que tenemos en la configuración de nuestra aplicación desde la consola.

mysql nombredelabasededatos -u miusuario -p

Digitamos la contraseña y presionamos enter para lograr acceso.

Si nos da un error como el que se ve en la imagen siguiente es porque el servicio no está activo.

Para activarlo deberemos ejecutar un comando como el que sigue desde la consola (como si fuéramos root):

service mysqld start

Si ahora logramos acceso y todo va bien, es decir, logramos conectarnos al servidor mysql, sería bueno saber si tenemos acceso a la base de datos que usará la aplicación.

Para eso, estando en la consola interactiva de mysql, escribimos el comando use mibasededatos; (donde mibasededatos es el nombre de la base de datos que está configurado en el archivo database.ini) seguido de punto y coma. Y presionamos enter.

Nos debe aparecer un mensaje como “database changed”.

Seleccionamos alguna de las tablas del sistema (podemos listarlas usando el comando show tables;), y escribimos alguna instrucción y le ejecutamos, por ejemplo;

<span class="token keyword">SELECT</span> <span class="token operator">*</span> <span class="token keyword">FROM</span> tablaseleccionada<span class="token punctuation">;</span>

Si todo ha ido bien, ya podemos pasar al siguiente punto.

¿La cuenta en el servidor de bases de datos es la que corresponde en la configuración de nuestra aplicación?

Bueno, en el punto anterior ya hemos realizado esta prueba usando el comando:

mysql nombrebasedatos -u usuario -p

Si esto no resulta, será necesario crear un usuario de mysql con los permisos necesarios sobre la base de datos correcta. Para eso te recomendamos leer el siguiente artículo que ya explica muy bien cómo lograr esta labor.

https://www.digitalocean.com/community/tutorials/crear-un-nuevo-usuario-y-otorgarle-permisos-en-mysql-es

¿Hemos trasladado todos los cambios desde el servidor de bases de datos de desarrollo hacia el servidor de producción?

A veces el error se produce porque tenemos tablas en el servidor de desarrollo que no hemos pasado al servidor de producción o porque alguna de las tablas de producción no tiene atributos (campos) nuevos que sí hemos estado usando en desarrollo. Hacer una revisión de las estructuras de las tablas será de gran ayuda si comparas cómo es el estado en ambos servidores.

¿Nuestra aplicación tiene los permisos bien configurados?

Si hemos leído los artículos de la wiki, y hemos comprobado que los permisos son los correctos, sólo nos quedará pasar al siguiente punto.

¿Hemos copiado completamente la aplicación desde el servidor de desarrollo (incluidos todos los archivos ocultos)?

Por obvia que parezca la pregunta, resulta que en ocasiones el cliente que usamos para copiar los archivos, omite los archivos ocultos que comienzan en punto (los dot files). En KumbiaPHP se usan varios archivos que comienzan en punto, y aunque todos se llaman igual, cada uno cumple una misión diferente dependiendo del lugar en el que esté alojado. Este archivo es el .htaccess.

Personalmente la forma que más me resulta para lidiar con este problema es comprimir el sitio, copiarlo comprimido al servidor de producción y luego descomprimirlo en él. Si esto no fuera posible (porque por ejemplo no tienes acceso a la shell o si el panel web de administración no provee de gestión de archivos), toma en cuenta que el cliente de ftp que uses lleve todo lo que necesitas al servidor de producción.

¿Hemos configurado correctamente la constante PUBLIC_PATH?

Aunque también es parte de lo que se habla en los artículos escritos y mencionados de la wiki, uno de nuestros colegas ha escrito un artículo interesante sobre este tema y el siguiente en el blog de KumbiaPHP https://www.kumbiaphp.com/blog/2018/07/31/no-input-file-specified-arreglar-el-error/

¿Podemos usar PATH_INFO o necesitamos cambiar la estrategia de generación de URL?

Al igual que el punto anterior, nuestra recomendación es leer el artículo que ya se mencionó en él.

Si estamos completamente a ciegas, ¿hemos activado la visualización de errores?

Si el servidor no nos da información alguna sobre el error, podemos aprovechar una configuración especial que está alojada dentro del archivo default/public/index.php para activar el registro de los errores y permitir visualizarlos directamente en el navegador web.

Para eso iremos archivo mencionado (default/public/index.php) y buscaremos la línea:

//error_reporting(E_ALL ^ E_STRICT);ini_set('display_errors', 'On');

Y le quitaremos los comentarios iniciales, es decir, los dos primeros caracteres iniciales //

Adicionalmente debemos asegurarnos que KumbiaPHP no esté en modo producción, así que en el mismo archivo default/public/index.php verificamos que la constante PRODUCTION sea igual a false:

const PRODUCTION = false;

Esto hará que las excepciones que ocurran sean mostradas en pantalla evitando la redirección a la página de error 404, que es comportamiento por defecto de KumbiaPHP cuando está en producción.

Con eso ya tendremos alguna idea a partir de la presentación de los errores en pantalla.

Existe una forma extra de visualizar errores, pero para ello hay que tener acceso al servidor en modo consola (shell) y tener acceso al log de errores del servidor web (apache generalmente). Normalmente este archivo se aloja en /var/log/apache2/error.log

Si se tiene acceso a él, usar el comando tail -f error.log será de gran utilidad pues cada vez que recargues tu navegador, los errores se verán reflejados en tu terminal. Los mensajes que recibas serán de gran utilidad al momento de buscar posibles soluciones, o para pedir apoyo a algún colega.

El sitio presenta un error ERR_TOO_MANY_REDIRECTS al cargarlo

Si a pesar de haber eliminado los archivos de la caché este error persiste es momento de revisar nuestra rutina de autenticación. En ocasiones la implementación de la gestión de la sesión del usuario nos puede causar algunos dolores de cabeza, y el consejo aquí es verificar la forma en la cual se lleva a cabo las redirecciones cuando un usuario no tiene los privilegios necesarios y requiere de autenticación. Hay diferentes formas de llevar a cabo la autenticación, pero siempre vale la pena consultar alguna forma que ya haya sido probada. Para tales efectos les recomendamos leer http://wiki.kumbiaphp.com/Beta2_Sistema_de_Login o también https://soyprogramador.liz.mx/implementando-logueo-en-kumbiaphp/ como elementos formativos. Te dejamos como tarea extra mirar código de otras personas. Puedes hacer una búsqueda en github con la palabra clave kumbiaphp.

Una recomendación final

Si hemos pasado de PRODUCCION = true a false y viceversa, es necesario recordar eliminar el contenido de la carpeta de cache que genera KumbiaPHP cuando estamos en modo producción. Para ello iremos a la carpeta default/app/temp/cache y borraremos su contenido para evitar que no logremos visualizar los errores porque el framework está presentando los contenidos “cacheados” en vez de las vistas reales.

Con todo esto, te deseamos lo mejor y mucho ánimo cuando te encuentres con un problema, pues recuerda que resolverlos es parte de nuestro aprendizaje y nuestra labor como desarrolladores.

Un abrazo cordial,

El equipo de KumbiaPHP

La entrada Errores comunes al subir web o aplicación php a producción se publicó primero en KumbiaPHP Framework PHP en español.

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

<?php

// Require composer autoload
require_once APP_PATH . '../../vendor/autoload.php';

use Mpdf\Mpdf;

/** 
 *
 * Controller por defecto si no se usa el routes 
 *
 */
class IndexController extends AppController
{
    public function index()
    {
    }
}

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.

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

<h1>¡Hola KumbiaPHP!</h1>

Ahora si el método example2() en el modelo:

Archivo: default/app/models/html_to_pdf.php

<?php 
use Mpdf\Mpdf; 

class HtmlToPdf 
{ 
    public static function example2() 
    { 
        // Activa el almacenamiento en búfer de la salida 
        ob_start(); 
        // Carga el contenido del partial 
        View::partial('pdf/example2'); 
        // 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); 
        // 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

<h1>¡Hola <?= $name ?>!</h1>
<p> Este documento fue generado el <?= $date ?> </p>

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:

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.