Pagine personalizzate con plugin

Quando visiti una pagina frontend, WordPress eseguirà una query al database e se la tua pagina non esiste nel database, quella query non è necessaria e rappresenta solo uno spreco di risorse.

Fortunatamente, WordPress offre un modo per gestire le richieste frontend in modo personalizzato. Questo è possibile grazie al filtro 'do_parse_request'.

Restituendo false su questo hook, sarai in grado di interrompere il normale processo di gestione delle richieste da parte di WordPress e gestirle in modo personalizzato.

Detto questo, voglio condividere un modo per costruire un semplice plugin OOP che possa gestire pagine virtuali in modo semplice da usare (e riutilizzare).

Cosa ci serve

• Una classe per gli oggetti pagina virtuale
• Una classe controller, che esaminerà una richiesta e, se è per una pagina virtuale, la mostrerà utilizzando il template appropriato
• Una classe per il caricamento dei template
• I file principali del plugin per aggiungere gli hook che faranno funzionare tutto

Interfacce

Prima di costruire le classi, scriviamo le interfacce per i 3 oggetti elencati sopra.

Iniziamo con l'interfaccia della pagina (file PageInterface.php):

<?php
namespace GM\VirtualPages;

interface PageInterface {

    function getUrl();

    function getTemplate();

    function getTitle();

    function setTitle( $title );

    function setContent( $content );

    function setTemplate( $template );

    /**
     * Ottieni un oggetto WP_Post costruito dall'oggetto Page virtuale
     *
     * @return \WP_Post
     */
    function asWpPost();
}

La maggior parte dei metodi sono semplici getter e setter, non c'è bisogno di spiegazioni. L'ultimo metodo dovrebbe essere utilizzato per ottenere un oggetto WP_Post da una pagina virtuale.

L'interfaccia del controller (file ControllerInterface.php):

<?php
namespace GM\VirtualPages;

interface ControllerInterface {

    /**
     * Inizializza il controller, attiva l'hook che consente ai consumer di aggiungere pagine
     */
    function init();

    /**
     * Registra un oggetto pagina nel controller
     *
     * @param  \GM\VirtualPages\Page $page
     * @return \GM\VirtualPages\Page
     */
    function addPage( PageInterface $page );

    /**
     * Eseguito su 'do_parse_request' e se la richiesta è per una delle pagine registrate
     * configura le variabili globali, attiva gli hook core, carica il template della pagina e termina.
     *
     * @param boolean $bool Il valore booleano passato da 'do_parse_request'
     * @param \WP $wp       L'oggetto wp globale passato da 'do_parse_request'
     */  
    function dispatch( $bool, \WP $wp ); 
}

e l'interfaccia del caricatore di template (file TemplateLoaderInterface.php ):

<?php
namespace GM\VirtualPages;

interface TemplateLoaderInterface {

    /**
     * Configura il caricatore per un oggetto pagina
     *
     * @param \GM\VirtualPagesPageInterface $page la pagina virtuale corrispondente
     */
    public function init( PageInterface $page );

    /**
     * Attiva gli hook core e personalizzati per filtrare i template,
     * quindi carica il template trovato.
     */
    public function load();
}

I commenti phpDoc dovrebbero essere abbastanza chiari per queste interfacce.

Il Piano

Ora che abbiamo le interfacce, e prima di scrivere le classi concrete, rivediamo il nostro flusso di lavoro:

• Per prima cosa istanziamo una classe Controller (che implementa ControllerInterface) e iniettiamo (probabilmente in un costruttore) un'istanza della classe TemplateLoader (che implementa TemplateLoaderInterface)
• Sull'hook init chiamiamo il metodo ControllerInterface::init() per configurare il controller e attivare l'hook che il codice consumer utilizzerà per aggiungere pagine virtuali.
• Su 'do_parse_request' chiameremo ControllerInterface::dispatch(), e lì controlleremo tutte le pagine virtuali aggiunte e se una di esse ha lo stesso URL della richiesta corrente, la mostreremo; dopo aver impostato tutte le variabili globali core ($wp_query, $post). Utilizzeremo anche la classe TemplateLoader per caricare il template corretto.

Durante questo flusso di lavoro attiveremo alcuni hook core, come wp, template_redirect, template_include... per rendere il plugin più flessibile e garantire la compatibilità con il core e altri plugin, o almeno con un buon numero di essi.

Oltre al flusso di lavoro precedente, avremo anche bisogno di:

• Pulire gli hook e le variabili globali dopo l'esecuzione del main loop, sempre per migliorare la compatibilità con il core e il codice di terze parti
• Aggiungere un filtro su the_permalink per farlo restituire l'URL corretto della pagina virtuale quando necessario.

Classi Concrete

Ora possiamo codificare le nostre classi concrete. Iniziamo con la classe pagina (file 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 = 'Untitled', $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;
    }
}

Nulla di più che implementare l'interfaccia.

Ora la classe controller (file 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();
    }
}

Essenzialmente la classe crea un oggetto SplObjectStorage dove vengono memorizzati tutti gli oggetti pagina aggiunti.

Su 'do_parse_request', la classe controller esegue un loop su questo storage per trovare una corrispondenza tra l'URL corrente e uno degli URL delle pagine aggiunte.

Se viene trovata una corrispondenza, la classe fa esattamente ciò che avevamo pianificato: attiva alcuni hook, configura le variabili e carica il template tramite la classe che estende TemplateLoaderInterface. Dopodiché, semplicemente exit().

Quindi scriviamo l'ultima classe:

<?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;
        }
    }
}

I template memorizzati nella pagina virtuale vengono uniti in un array con i default page.php e index.php, prima del caricamento del template viene attivato 'template_redirect', per aggiungere flessibilità e migliorare la compatibilità.

Successivamente, il template trovato passa attraverso il filtro personalizzato 'virtual_page_template' e il filtro core 'template_include': ancora una volta per flessibilità e compatibilità.

Infine il file del template viene semplicemente caricato.

File principale del plugin

A questo punto dobbiamo scrivere il file con gli header del plugin e utilizzarlo per aggiungere gli hook che faranno funzionare il nostro flusso di lavoro:

<?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;
} );

Nel file reale probabilmente aggiungeremo più header, come link al plugin e all'autore, descrizione, licenza, ecc.

Gist del Plugin

Ok, abbiamo finito con il nostro plugin. Tutto il codice può essere trovato in un Gist qui.

Aggiunta di Pagine

Il plugin è pronto e funzionante, ma non abbiamo ancora aggiunto alcuna pagina.

Questo può essere fatto all'interno del plugin stesso, all'interno del file functions.php del tema, in un altro plugin, ecc.

Aggiungere pagine è solo una questione di:

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

    // prima pagina
    $controller->addPage( new \GM\VirtualPages\Page( '/custom/page' ) )
        ->setTitle( 'My First Custom Page' )
        ->setTemplate( 'custom-page-form.php' );

    // seconda pagina
    $controller->addPage( new \GM\VirtualPages\Page( '/custom/page/deep' ) )
        ->setTitle( 'My Second Custom Page' )
        ->setTemplate( 'custom-page-deep.php' );

} );

E così via. Puoi aggiungere tutte le pagine di cui hai bisogno, ricorda solo di utilizzare URL relativi per le pagine.

All'interno del file template puoi utilizzare tutti i tag template di WordPress, e puoi scrivere tutto il PHP e HTML di cui hai bisogno.

L'oggetto post globale è riempito con i dati provenienti dalla nostra pagina virtuale. La pagina virtuale stessa può essere acceduta tramite la variabile $wp_query->virtual_page.

Ottenere l'URL per una pagina virtuale è facile come passare a home_url() lo stesso percorso utilizzato per creare la pagina:

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

Nota che nel main loop nel template caricato, the_permalink() restituirà il permalink corretto alla pagina virtuale.

Note su stili / script per pagine virtuali

Probabilmente quando vengono aggiunte pagine virtuali, è anche desiderabile avere stili/script personalizzati enqueued e quindi semplicemente utilizzare wp_head() nei template personalizzati.

Questo è molto semplice, perché le pagine virtuali sono facilmente riconoscibili controllando la variabile $wp_query->virtual_page e le pagine virtuali possono essere distinte l'una dall'altra controllando i loro URL.

Un semplice esempio:

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;
        }
    }

} );

Note per OP

Passare dati da una pagina all'altra non è correlato a queste pagine virtuali, ma è un compito generico.

Tuttavia, se hai un form nella prima pagina e vuoi passare dati da lì alla seconda pagina, usa semplicemente l'URL della seconda pagina nella proprietà action del form.

Ad esempio, nel file template della prima pagina puoi:

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

e poi nel file template della seconda pagina:

<?php $testme = filter_input( INPUT_POST, 'testme', FILTER_SANITIZE_STRING ); ?>
<h1>Il valore Test-Me dall'altra pagina è: <?php echo $testme; ?></h1>