Pagini personalizate cu ajutorul unui plugin

Când vizitați o pagină frontend, WordPress va interoga baza de date, iar dacă pagina dumneavoastră nu există în baza de date, acea interogare nu este necesară și reprezintă doar o pierdere de resurse.

Din fericire, WordPress oferă o modalitate de a gestiona cererile frontend într-un mod personalizat. Acest lucru se realizează datorită filtrului 'do_parse_request'.

Returnând false pe acest hook, veți putea opri WordPress din procesarea cererilor și o veți face în modul dumneavoastră personalizat.

Cu aceasta menționată, doresc să împărtășesc o metodă de a construi un simplu plugin OOP care poate gestiona pagini virtuale într-un mod ușor de utilizat (și reutilizat).

Ce avem nevoie

• O clasă pentru obiectele paginilor virtuale
• O clasă controler, care va analiza o cerere și, dacă este pentru o pagină virtuală, o va afișa folosind șablonul corespunzător
• O clasă pentru încărcarea șabloanelor
• Fișierele principale ale pluginului pentru a adăuga hook-urile care vor face totul să funcționeze

Interfețe

Înainte de a construi clasele, să scriem interfețele pentru cele 3 obiecte enumerate mai sus.

Mai întâi interfața pentru pagină (fișierul PageInterface.php):

<?php
namespace GM\VirtualPages;

interface PageInterface {

    function getUrl();

    function getTemplate();

    function getTitle();

    function setTitle( $title );

    function setContent( $content );

    function setTemplate( $template );

    /**
     * Obține un obiect WP_Post construit folosind obiectul Page virtual
     *
     * @return \WP_Post
     */
    function asWpPost();
}

Majoritatea metodelor sunt doar getteri și setteri, nu necesită explicații. Ultima metodă ar trebui utilizată pentru a obține un obiect WP_Post dintr-o pagină virtuală.

Interfața controlerului (fișierul ControllerInterface.php):

<?php
namespace GM\VirtualPages;

interface ControllerInterface {

    /**
     * Inițializează controlerul, lansează hook-ul care permite consumatorilor să adauge pagini
     */
    function init();

    /**
     * Înregistrează un obiect de pagină în controler
     *
     * @param  \GM\VirtualPages\Page $page
     * @return \GM\VirtualPages\Page
     */
    function addPage( PageInterface $page );

    /**
     * Rulează pe 'do_parse_request' și dacă cererea este pentru una din paginile înregistrate
     * configurează variabilele globale, lansează hook-urile nucleu, încarcă șablonul paginii și iese.
     *
     * @param boolean $bool Valoarea booleană transmisă de 'do_parse_request'
     * @param \WP $wp       Obiectul global wp transmis de 'do_parse_request'
     */  
    function dispatch( $bool, \WP $wp ); 
}

și interfața pentru încărcarea șabloanelor (fișierul TemplateLoaderInterface.php ):

<?php
namespace GM\VirtualPages;

interface TemplateLoaderInterface {

    /**
     * Configurează încărcătorul pentru un obiect de pagină
     *
     * @param \GM\VirtualPagesPageInterface $page pagină virtuală potrivită
     */
    public function init( PageInterface $page );

    /**
     * Lansează hook-urile nucleu și personalizate pentru a filtra șabloanele,
     * apoi încarcă șablonul găsit.
     */
    public function load();
}

Comentariile phpDoc ar trebui să fie destul de clare pentru aceste interfețe.

Planul

Acum că avem interfețele și înainte de a scrie clasele concrete, să revizuim fluxul de lucru:

• Mai întâi instanțiem o clasă Controller (care implementează ControllerInterface) și injectăm (probabil într-un constructor) o instanță a clasei TemplateLoader (care implementează TemplateLoaderInterface)
• Pe hook-ul init apelăm metoda ControllerInterface::init() pentru a configura controlerul și pentru a lansa hook-ul pe care codul consumator îl va folosi pentru a adăuga pagini virtuale.
• Pe 'do_parse_request' vom apela ControllerInterface::dispatch(), și acolo vom verifica toate paginile virtuale adăugate și dacă una dintre ele are același URL ca cererea curentă, o vom afișa; după ce am setat toate variabilele globale nucleu ($wp_query, $post). Vom folosi și clasa TemplateLoader pentru a încărca șablonul corespunzător.

În timpul acestui flux de lucru vom declanșa unele hook-uri nucleu, cum ar fi wp, template_redirect, template_include... pentru a face pluginul mai flexibil și a asigura compatibilitatea cu nucleul și alte pluginuri, sau cel puțin cu un număr bun dintre ele.

Pe lângă fluxul de lucru anterior, vom avea nevoie și de:

• Curățarea hook-urilor și variabilelor globale după ce rulează bucla principală, din nou pentru a îmbunătăți compatibilitatea cu nucleul și codul terților
• Adăugarea unui filtru pe the_permalink pentru a face să returneze URL-ul corect al paginii virtuale când este necesar.

Clasele Concrete

Acum putem scrie clasele noastre concrete. Să începem cu clasa pentru pagină (fișierul 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;
    }
}

Nu mai mult decât implementarea interfeței.

Acum clasa controler (fișierul 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();
    }
}

În esență, clasa creează un obiect SplObjectStorage în care sunt stocate toate obiectele de pagini adăugate.

Pe 'do_parse_request', clasa controler parcurge acest depozit pentru a găsi o potrivire pentru URL-ul curent într-una din paginile adăugate.

Dacă este găsită, clasa face exact ceea ce am planificat: declanșează unele hook-uri, configurează variabilele și încarcă șablonul prin clasa care extinde TemplateLoaderInterface. După aceea, pur și simplu exit().

Deci, să scriem ultima clasă:

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

Șabloanele stocate în pagina virtuală sunt combinate într-un array cu valorile implicite page.php și index.php, înainte de încărcarea șablonului 'template_redirect' este declanșat, pentru a adăuga flexibilitate și a îmbunătăți compatibilitatea.

După aceea, șablonul găsit trece prin filtrul personalizat 'virtual_page_template' și filtrul nucleu 'template_include': din nou pentru flexibilitate și compatibilitate.

În final, fișierul șablon este încărcat.

Fișierul principal al pluginului

În acest moment, trebuie să scriem fișierul cu antetele pluginului și să-l folosim pentru a adăuga hook-urile care vor face fluxul nostru de lucru să se întâmple:

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

În fișierul real, vom adăuga probabil mai multe antete, cum ar fi link-uri pentru plugin și autor, descriere, licență, etc.

Gist-ul Pluginului

Ok, am terminat cu pluginul nostru. Tot codul poate fi găsit într-un Gist aici.

Adăugarea Paginilor

Pluginul este gata și funcționează, dar nu am adăugat nicio pagină.

Aceasta poate fi făcută în interiorul pluginului în sine, în fișierul functions.php al temei, în alt plugin, etc.

Adăugarea paginilor este doar o chestiune de:

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

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

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

} );

Și așa mai departe. Puteți adăuga toate paginile de care aveți nevoie, doar amintiți-vă să folosiți URL-uri relative pentru pagini.

În interiorul fișierului șablon, puteți folosi toate etichetele de șabloane WordPress și puteți scrie tot PHP și HTML de care aveți nevoie.

Obiectul global post este umplut cu date provenite din pagina noastră virtuală. Pagina virtuală în sine poate fi accesată prin variabila $wp_query->virtual_page.

Pentru a obține URL-ul unei pagini virtuale este la fel de ușor ca transmiterea către home_url() a aceleiași căi folosite pentru a crea pagina:

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

Rețineți că în bucla principală din șablonul încărcat, the_permalink() va returna permalinkul corect către pagina virtuală.

Note despre stiluri / scripturi pentru paginile virtuale

Probabil, atunci când se adaugă pagini virtuale, este de dorit să avem și stiluri/scripturi personalizate încărcate și apoi să folosim doar wp_head() în șabloanele personalizate.

Aceasta este foarte ușor, deoarece paginile virtuale sunt ușor de recunoscut uitându-ne la variabila $wp_query->virtual_page și paginile virtuale pot fi distinse una de alta uitându-ne la URL-urile lor.

Doar un exemplu:

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 pentru OP

Transmiterea datelor de la o pagină la alta nu este legată de aceste pagini virtuale, ci este doar o sarcină generică.

Cu toate acestea, dacă aveți un formular în prima pagină și doriți să transmiteți date de acolo către a doua pagină, pur și simplu folosiți URL-ul celei de-a doua pagini în proprietatea action a formularului.

De exemplu, în fișierul șablon al primei pagini puteți:

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

și apoi în fișierul șablon al celei de-a doua pagini:

<?php $testme = filter_input( INPUT_POST, 'testme', FILTER_SANITIZE_STRING ); ?>
<h1>Test-Me value form other page is: <?php echo $testme; ?></h1>