Páginas personalizadas con plugin

Cuando visitas una página en el frontend, WordPress consultará la base de datos y si tu página no existe en la base de datos, esa consulta no es necesaria y solo es un desperdicio de recursos.

Afortunadamente, WordPress ofrece una manera de manejar las solicitudes del frontend de forma personalizada. Esto se logra gracias al filtro 'do_parse_request'.

Devolviendo false en ese hook, podrás detener el procesamiento de solicitudes por parte de WordPress y hacerlo a tu manera personalizada.

Dicho esto, quiero compartir una forma de construir un plugin simple orientado a objetos (OOP) que pueda manejar páginas virtuales de una manera fácil de usar (y reutilizar).

Lo que necesitamos

• Una clase para objetos de página virtual
• Una clase controladora, que examinará una solicitud y si es para una página virtual, la mostrará usando la plantilla adecuada
• Una clase para cargar plantillas
• Archivos principales del plugin para agregar los hooks que harán que todo funcione

Interfaces

Antes de construir las clases, escribamos las interfaces para los 3 objetos mencionados anteriormente.

Primero la interfaz de página (archivo PageInterface.php):

<?php
namespace GM\VirtualPages;

interface PageInterface {

    function getUrl();

    function getTemplate();

    function getTitle();

    function setTitle( $title );

    function setContent( $content );

    function setTemplate( $template );

    /**
     * Obtener un WP_Post construido usando el objeto de página virtual
     *
     * @return \WP_Post
     */
    function asWpPost();
}

La mayoría de los métodos son solo getters y setters, no necesitan explicación. El último método debería usarse para obtener un objeto WP_Post desde una página virtual.

La interfaz del controlador (archivo ControllerInterface.php):

<?php
namespace GM\VirtualPages;

interface ControllerInterface {

    /**
     * Inicializar el controlador, dispara el hook que permite a los consumidores agregar páginas
     */
    function init();

    /**
     * Registrar un objeto de página en el controlador
     *
     * @param  \GM\VirtualPages\Page $page
     * @return \GM\VirtualPages\Page
     */
    function addPage( PageInterface $page );

    /**
     * Se ejecuta en 'do_parse_request' y si la solicitud es para una de las páginas registradas
     * configura variables globales, dispara hooks del núcleo, requiere la plantilla de página y termina.
     *
     * @param boolean $bool El valor booleano pasado por 'do_parse_request'
     * @param \WP $wp       El objeto global wp pasado por 'do_parse_request'
     */  
    function dispatch( $bool, \WP $wp ); 
}

y la interfaz del cargador de plantillas (archivo TemplateLoaderInterface.php ):

<?php
namespace GM\VirtualPages;

interface TemplateLoaderInterface {

    /**
     * Configurar el cargador para un objeto de página
     *
     * @param \GM\VirtualPagesPageInterface $page página virtual coincidente
     */
    public function init( PageInterface $page );

    /**
     * Disparar hooks del núcleo y personalizados para filtrar plantillas,
     * luego cargar la plantilla encontrada.
     */
    public function load();
}

Los comentarios phpDoc deberían ser bastante claros para estas interfaces.

El Plan

Ahora que tenemos las interfaces, y antes de escribir las clases concretas, revisemos nuestro flujo de trabajo:

• Primero instanciamos una clase Controller (implementando ControllerInterface) e inyectamos (probablemente en un constructor) una instancia de la clase TemplateLoader (implementando TemplateLoaderInterface)
• En el hook init llamamos al método ControllerInterface::init() para configurar el controlador y disparar el hook que el código consumidor usará para agregar páginas virtuales.
• En 'do_parse_request' llamaremos a ControllerInterface::dispatch(), y allí verificaremos todas las páginas virtuales agregadas y si una de ellas tiene la misma URL que la solicitud actual, la mostraremos; después de haber configurado todas las variables globales del núcleo ($wp_query, $post). También usaremos la clase TemplateLoader para cargar la plantilla correcta.

Durante este flujo de trabajo dispararemos algunos hooks del núcleo, como wp, template_redirect, template_include... para hacer el plugin más flexible y garantizar compatibilidad con el núcleo y otros plugins, o al menos con una buena cantidad de ellos.

Además del flujo de trabajo anterior, también necesitaremos:

• Limpiar hooks y variables globales después de que se ejecute el bucle principal, nuevamente para mejorar la compatibilidad con el núcleo y código de terceros
• Agregar un filtro en the_permalink para que devuelva la URL correcta de la página virtual cuando sea necesario.

Clases Concretas

Ahora podemos codificar nuestras clases concretas. Comencemos con la clase de página (archivo Page.php):

<?php
namespace GM\VirtualPages;

class Page implements PageInterface {

    private $url;
    private $title;
    private $content;
    private $template;
    private $wp_post;

    function __construct( $url, $title = 'Sin título', $template = 'page.php' ) {
        $this->url = filter_var( $url, FILTER_SANITIZE_URL );
        $this->setTitle( $title );
        $this->setTemplate( $template);
    }

    function getUrl() {
        return $this->url;
    }

    function getTemplate() {
        return $this->template;
    }

    function getTitle() {
        return $this->title;
    }

    function setTitle( $title ) {
        $this->title = filter_var( $title, FILTER_SANITIZE_STRING );
        return $this;
    }

    function setContent( $content ) {
        $this->content = $content;
        return $this;
    }

    function setTemplate( $template ) {
        $this->template = $template;
        return $this;
    }

    function asWpPost() {
        if ( is_null( $this->wp_post ) ) {
            $post = array(
                'ID'             => 0,
                'post_title'     => $this->title,
                'post_name'      => sanitize_title( $this->title ),
                'post_content'   => $this->content ? : '',
                'post_excerpt'   => '',
                'post_parent'    => 0,
                'menu_order'     => 0,
                'post_type'      => 'page',
                'post_status'    => 'publish',
                'comment_status' => 'closed',
                'ping_status'    => 'closed',
                'comment_count'  => 0,
                'post_password'  => '',
                'to_ping'        => '',
                'pinged'         => '',
                'guid'           => home_url( $this->getUrl() ),
                'post_date'      => current_time( 'mysql' ),
                'post_date_gmt'  => current_time( 'mysql', 1 ),
                'post_author'    => is_user_logged_in() ? get_current_user_id() : 0,
                'is_virtual'     => TRUE,
                'filter'         => 'raw'
            );
            $this->wp_post = new \WP_Post( (object) $post );
        }
        return $this->wp_post;
    }
}

Nada más que implementar la interfaz.

Ahora la clase controladora (archivo Controller.php):

<?php
namespace GM\VirtualPages;

class Controller implements ControllerInterface {

    private $pages;
    private $loader;
    private $matched;

    function __construct( TemplateLoaderInterface $loader ) {
        $this->pages = new \SplObjectStorage;
        $this->loader = $loader;
    }

    function init() {
        do_action( 'gm_virtual_pages', $this ); 
    }

    function addPage( PageInterface $page ) {
        $this->pages->attach( $page );
        return $page;
    }

    function dispatch( $bool, \WP $wp ) {
        if ( $this->checkRequest() && $this->matched instanceof Page ) {
            $this->loader->init( $this->matched );
            $wp->virtual_page = $this->matched;
            do_action( 'parse_request', $wp );
            $this->setupQuery();
            do_action( 'wp', $wp );
            $this->loader->load();
            $this->handleExit();
        }
        return $bool;
    }

    private function checkRequest() {
        $this->pages->rewind();
        $path = trim( $this->getPathInfo(), '/' );
        while( $this->pages->valid() ) {
            if ( trim( $this->pages->current()->getUrl(), '/' ) === $path ) {
                $this->matched = $this->pages->current();
                return TRUE;
            }
            $this->pages->next();
        }
    }        

    private function getPathInfo() {
        $home_path = parse_url( home_url(), PHP_URL_PATH );
        return preg_replace( "#^/?{$home_path}/#", '/', esc_url( add_query_arg(array()) ) );
    }

    private function setupQuery() {
        global $wp_query;
        $wp_query->init();
        $wp_query->is_page       = TRUE;
        $wp_query->is_singular   = TRUE;
        $wp_query->is_home       = FALSE;
        $wp_query->found_posts   = 1;
        $wp_query->post_count    = 1;
        $wp_query->max_num_pages = 1;
        $posts = (array) apply_filters(
            'the_posts', array( $this->matched->asWpPost() ), $wp_query
        );
        $post = $posts[0];
        $wp_query->posts          = $posts;
        $wp_query->post           = $post;
        $wp_query->queried_object = $post;
        $GLOBALS['post']          = $post;
        $wp_query->virtual_page   = $post instanceof \WP_Post && isset( $post->is_virtual )
            ? $this->matched
            : NULL;
    }

    public function handleExit() {
        exit();
    }
}

Esencialmente la clase crea un objeto SplObjectStorage donde se almacenan todos los objetos de página agregados.

En 'do_parse_request', la clase controladora recorre este almacenamiento para encontrar una coincidencia para la URL actual en una de las páginas agregadas.

Si se encuentra, la clase hace exactamente lo que planeamos: dispara algunos hooks, configura variables y carga la plantilla a través de la clase que extiende TemplateLoaderInterface. Después de eso, simplemente exit().

Así que escribamos la última clase:

<?php
namespace GM\VirtualPages;

class TemplateLoader implements TemplateLoaderInterface {

    public function init( PageInterface $page ) {
        $this->templates = wp_parse_args(
            array( 'page.php', 'index.php' ), (array) $page->getTemplate()
        );
    }

    public function load() {
        do_action( 'template_redirect' );
        $template = locate_template( array_filter( $this->templates ) );
        $filtered = apply_filters( 'template_include',
            apply_filters( 'virtual_page_template', $template )
        );
        if ( empty( $filtered ) || file_exists( $filtered ) ) {
            $template = $filtered;
        }
        if ( ! empty( $template ) && file_exists( $template ) ) {
            require_once $template;
        }
    }
}

Las plantillas almacenadas en la página virtual se fusionan en un arreglo con los valores predeterminados page.php y index.php, antes de cargar la plantilla se dispara 'template_redirect', para agregar flexibilidad y mejorar la compatibilidad.

Después de eso, la plantilla encontrada pasa a través de los filtros personalizados 'virtual_page_template' y del núcleo 'template_include': nuevamente para flexibilidad y compatibilidad.

Finalmente el archivo de plantilla simplemente se carga.

Archivo principal del plugin

En este punto necesitamos escribir el archivo con los encabezados del plugin y usarlo para agregar los hooks que harán que nuestro flujo de trabajo ocurra:

<?php namespace GM\VirtualPages;

/*
  Plugin Name: GM Virtual Pages
 */

require_once 'PageInterface.php';
require_once 'ControllerInterface.php';
require_once 'TemplateLoaderInterface.php';
require_once 'Page.php';
require_once 'Controller.php';
require_once 'TemplateLoader.php';

$controller = new Controller ( new TemplateLoader );

add_action( 'init', array( $controller, 'init' ) );

add_filter( 'do_parse_request', array( $controller, 'dispatch' ), PHP_INT_MAX, 2 );

add_action( 'loop_end', function( \WP_Query $query ) {
    if ( isset( $query->virtual_page ) && ! empty( $query->virtual_page ) ) {
        $query->virtual_page = NULL;
    }
} );

add_filter( 'the_permalink', function( $plink ) {
    global $post, $wp_query;
    if (
        $wp_query->is_page && isset( $wp_query->virtual_page )
        && $wp_query->virtual_page instanceof Page
        && isset( $post->is_virtual ) && $post->is_virtual
    ) {
        $plink = home_url( $wp_query->virtual_page->getUrl() );
    }
    return $plink;
} );

En el archivo real probablemente agregaremos más encabezados, como enlaces del plugin y del autor, descripción, licencia, etc.

Gist del Plugin

Ok, hemos terminado con nuestro plugin. Todo el código se puede encontrar en un Gist aquí.

Agregando Páginas

El plugin está listo y funcionando, pero no hemos agregado ninguna página.

Eso se puede hacer dentro del propio plugin, dentro del functions.php del tema, en otro plugin, etc.

Agregar páginas es solo cuestión de:

<?php
add_action( 'gm_virtual_pages', function( $controller ) {

    // primera página
    $controller->addPage( new \GM\VirtualPages\Page( '/custom/page' ) )
        ->setTitle( 'Mi Primera Página Personalizada' )
        ->setTemplate( 'custom-page-form.php' );

    // segunda página
    $controller->addPage( new \GM\VirtualPages\Page( '/custom/page/deep' ) )
        ->setTitle( 'Mi Segunda Página Personalizada' )
        ->setTemplate( 'custom-page-deep.php' );

} );

Y así sucesivamente. Puedes agregar todas las páginas que necesites, solo recuerda usar URLs relativas para las páginas.

Dentro del archivo de plantilla puedes usar todas las etiquetas de plantilla de WordPress, y puedes escribir todo el PHP y HTML que necesites.

El objeto global post está lleno con datos provenientes de nuestra página virtual. La página virtual en sí puede ser accedida a través de la variable $wp_query->virtual_page.

Obtener la URL para una página virtual es tan fácil como pasar a home_url() la misma ruta usada para crear la página:

$custom_page_url = home_url( '/custom/page' );

Nota que en el bucle principal en la plantilla cargada, the_permalink() devolverá el permalink correcto a la página virtual.

Notas sobre estilos / scripts para páginas virtuales

Probablemente cuando se agregan páginas virtuales, también es deseable tener estilos/scripts personalizados encolados y luego simplemente usar wp_head() en las plantillas personalizadas.

Eso es muy fácil, porque las páginas virtuales se reconocen fácilmente mirando la variable $wp_query->virtual_page y las páginas virtuales se pueden distinguir unas de otras mirando sus URLs.

Solo un ejemplo:

add_action( 'wp_enqueue_scripts', function() {

    global $wp_query;

    if (
        is_page()
        && isset( $wp_query->virtual_page )
        && $wp_query->virtual_page instanceof \GM\VirtualPages\PageInterface
    ) {

        $url = $wp_query->virtual_page->getUrl();

        switch ( $url ) {
            case '/custom/page' : 
                wp_enqueue_script( 'a_script', $a_script_url );
                wp_enqueue_style( 'a_style', $a_style_url );
                break;
            case '/custom/page/deep' : 
                wp_enqueue_script( 'another_script', $another_script_url );
                wp_enqueue_style( 'another_style', $another_style_url );
                break;
        }
    }

} );

Notas para OP

Pasar datos de una página a otra no está relacionado con estas páginas virtuales, sino que es una tarea genérica.

Sin embargo, si tienes un formulario en la primera página y quieres pasar datos desde allí a la segunda página, simplemente usa la URL de la segunda página en la propiedad action del formulario.

Por ejemplo, en el archivo de plantilla de la primera página puedes:

<form action="<?php echo home_url( '/custom/page/deep' ); ?>" method="POST">
    <input type="text" name="testme">
</form>

y luego en el archivo de plantilla de la segunda página:

<?php $testme = filter_input( INPUT_POST, 'testme', FILTER_SANITIZE_STRING ); ?>
<h1>El valor Test-Me del otro página es: <?php echo $testme; ?></h1>