कस्टम पेज प्लगइन के साथ

Question

मैं कुछ प्लगइन विकसित कर रहा हूं जहां मैं कस्टम पेज को सक्षम करना चाहूंगा। मेरे मामले में कुछ कस्टम पृष्ठ में संपर्क फ़ॉर्म (शाब्दिक रूप से नहीं) जैसे फ़ॉर्म होंगे। जब उपयोगकर्ता इस फॉर्म को भर देगा और भेज देगा, तो अगला चरण होना चाहिए जिसे अधिक जानकारी की आवश्यकता होगी। कहते हैं कि फॉर्म वाला पहला पेज www.domain.tld/custom-page/सफल फॉर्म सबमिट करने के बाद स्थित होगा और उपयोगकर्ता को पुनर्निर्देशित किया जाना चाहिए www.domain.tld/custom-page/second। HTML तत्वों और PHP कोड के साथ टेम्पलेट भी कस्टम होना चाहिए।

मुझे लगता है कि कस्टम URL पुनर्लेखन के साथ समस्या का एक हिस्सा प्राप्त करना संभव है, लेकिन अन्य भाग वर्तमान में मेरे लिए अज्ञात हैं। मैं वास्तव में नहीं जानता कि मुझे कहां से देखना शुरू करना चाहिए और उस समस्या का सही नामकरण क्या है। किसी भी तरह की सहायता की सच में प्रशंसा की जाएगी।

Comments

क्या आप चाहते हैं कि ये पृष्ठ वर्डप्रेस या 'वर्चुअल' में संग्रहीत हों?

— वेल्डर

आपको फिर से लिखने के लिए एपीआई का उपयोग करना होगा। यह बहुत मुश्किल नहीं होना चाहिए। डेटा को दूसरे पृष्ठ पर पोस्ट करना सुनिश्चित करें और आपको ठीक होना चाहिए।

— सेटरगेट्टर

@Welcher: ये पृष्ठ डैशबोर्ड में वर्डप्रेस ऑफ़र के समान नहीं हैं। उन्हें केवल डेटाबेस में डेटा को सहेजना चाहिए, लेकिन यह समस्या नहीं है। @ .setterGetter: क्या आपके पास कोई उदाहरण है कि पहले पृष्ठ से दूसरे तक डेटा कैसे पास किया जाए और PHP फ़ाइल को शामिल करने के लिए (क्रिया?) जो कि फॉर्म दिखाता है?

— user1257255

क्या आपने इनपुट फ़ील्ड के एकाधिक स्लाइड (जावास्क्रिप्ट और / या सीएसएस) के साथ एक एकल पृष्ठ फ़ॉर्म का उपयोग करने पर विचार किया था?

— बीरगीर

Answer 1

जब आप एक दृश्य पृष्ठ पर जाते हैं, तो वर्डप्रेस डेटाबेस को क्वेरी करेगा और यदि आपका पेज डेटाबेस में मौजूद नहीं है, तो उस क्वेरी की आवश्यकता नहीं है और यह केवल संसाधनों की बर्बादी है।

सौभाग्य से, वर्डप्रेस कस्टम तरीके से फ्रंटेंड अनुरोधों को संभालने का एक तरीका प्रदान करता है। यह 'do_parse_request'फिल्टर के लिए धन्यवाद किया जाता है ।

falseउस हुक पर वापस लौटने पर, आप वर्डप्रेस को प्रसंस्करण अनुरोधों से रोकने में सक्षम होंगे और इसे अपने कस्टम तरीके से कर सकते हैं।

उस ने कहा, मैं एक साधारण ओओपी प्लगइन बनाने का एक तरीका साझा करना चाहता हूं जो आभासी पृष्ठों को उपयोग करने के लिए आसान (और पुनः उपयोग) तरीके से संभाल सकता है।

हमें क्या चाहिये

• वर्चुअल पेज ऑब्जेक्ट के लिए एक क्लास
• एक नियंत्रक वर्ग, जो एक अनुरोध को देखेगा और यदि यह एक आभासी पृष्ठ के लिए है, तो इसे उचित टेम्पलेट का उपयोग करके दिखाएं
• टेम्पलेट लोड करने के लिए एक वर्ग
• मुख्य प्लगइन फ़ाइलें हुक जोड़ने के लिए जो सब कुछ काम कर देगा

इंटरफेस

कक्षाएं बनाने से पहले, ऊपर सूचीबद्ध 3 ऑब्जेक्ट के लिए इंटरफेस लिखें।

पहला पेज इंटरफ़ेस (फ़ाइल PageInterface.php):

<?php
namespace GM\VirtualPages;

interface PageInterface {

    function getUrl();

    function getTemplate();

    function getTitle();

    function setTitle( $title );

    function setContent( $content );

    function setTemplate( $template );

    /**
     * Get a WP_Post build using virtual Page object
     *
     * @return \WP_Post
     */
    function asWpPost();
}

अधिकांश विधियां सिर्फ गेटर्स और सेटर हैं, स्पष्टीकरण की कोई आवश्यकता नहीं है। WP_Postवर्चुअल पेज से ऑब्जेक्ट प्राप्त करने के लिए अंतिम विधि का उपयोग किया जाना चाहिए ।

नियंत्रक इंटरफ़ेस (फ़ाइल ControllerInterface.php):

<?php
namespace GM\VirtualPages;

interface ControllerInterface {

    /**
     * Init the controller, fires the hook that allows consumer to add pages
     */
    function init();

    /**
     * Register a page object in the controller
     *
     * @param  \GM\VirtualPages\Page $page
     * @return \GM\VirtualPages\Page
     */
    function addPage( PageInterface $page );

    /**
     * Run on 'do_parse_request' and if the request is for one of the registered pages
     * setup global variables, fire core hooks, requires page template and exit.
     *
     * @param boolean $bool The boolean flag value passed by 'do_parse_request'
     * @param \WP $wp       The global wp object passed by 'do_parse_request'
     */  
    function dispatch( $bool, \WP $wp ); 
}

और टेम्पलेट लोडर इंटरफ़ेस (फ़ाइल TemplateLoaderInterface.php):

<?php
namespace GM\VirtualPages;

interface TemplateLoaderInterface {

    /**
     * Setup loader for a page objects
     *
     * @param \GM\VirtualPagesPageInterface $page matched virtual page
     */
    public function init( PageInterface $page );

    /**
     * Trigger core and custom hooks to filter templates,
     * then load the found template.
     */
    public function load();
}

इन इंटरफेस के लिए phpDoc टिप्पणियाँ बहुत स्पष्ट होनी चाहिए।

योजना

अब जब हमारे पास इंटरफेस है, और कंक्रीट कक्षाएं लिखने से पहले, हम अपने वर्कफ़्लो की समीक्षा करें:

• पहले हम एक Controllerकक्षा को लागू करते हैं (लागू करते हैं ControllerInterface) और इंजेक्ट करते हैं (शायद एक कंस्ट्रक्टर में) TemplateLoaderकक्षा का एक उदाहरण (कार्यान्वयन TemplateLoaderInterface)
• पर initहुक हम फोन ControllerInterface::init()सेटअप करने के लिए विधि नियंत्रक और हुक है कि उपभोक्ता कोड आभासी पृष्ठों को जोड़ने के लिए प्रयोग करेंगे आग।
• पर 'do_parse_request' हम फोन करेगा ControllerInterface::dispatch(), और वहाँ हम सब आभासी पृष्ठ जोड़ की जाँच करेगा और अगर उनमें से एक वर्तमान अनुरोध के समान URL है, यह प्रदर्शित करती हैं; सभी मुख्य वैश्विक चर ( $wp_query, $post) सेट करने के बाद । हम TemplateLoaderसही टेम्पलेट को लोड करने के लिए क्लास का भी उपयोग करेंगे ।

इस दौरान कार्यप्रवाह हम ट्रिगर किया जाएगा कुछ कोर हुक, जैसे wp, template_redirect,template_include ... प्लगइन अधिक लचीला बनाने और कोर और अन्य प्लग-इन, या उनमें से एक अच्छी संख्या के साथ कम से कम के साथ संगतता सुनिश्चित करने के लिए।

पिछले वर्कफ़्लो के अलावा, हमें यह भी करना होगा:

• मुख्य लूप चलने के बाद हुक और वैश्विक चर को साफ करें, फिर से कोर और 3 पार्टी कोड के साथ संगतता में सुधार करने के लिए
• the_permalinkजरूरत पड़ने पर सही वर्चुअल पेज URL को वापस करने के लिए एक फ़िल्टर जोड़ें ।

कंक्रीट कक्षाएं

अब हम अपने ठोस वर्गों को कोड कर सकते हैं। पेज क्लास (फाइल 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;
    }
}

इंटरफ़ेस को लागू करने से ज्यादा कुछ नहीं।

अब नियंत्रक वर्ग (फ़ाइल 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();
    }
}

अनिवार्य रूप से वर्ग ए बनाता है SplObjectStorage ऑब्जेक्ट जहां सभी जोड़े गए पृष्ठ ऑब्जेक्ट संग्रहीत होते हैं।

पर 'do_parse_request' , नियंत्रक वर्ग जोड़े गए पृष्ठों में से एक में वर्तमान URL के लिए एक मैच खोजने के लिए इस स्टोरेज को लूप करता है।

यदि यह पाया जाता है, तो क्लास बिल्कुल वही करता है जो हमने योजना बनाई थी: कुछ हुक ट्रिगर करें, सेटअप वेरिएबल और टेम्प्लेट को क्लास के माध्यम से लोड करें TemplateLoaderInterface। उसके बाद, बस exit()।

तो चलिए लिखते हैं आखिरी क्लास:

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

वर्चुअल पेज में संग्रहीत टेम्प्लेट को डिफ़ॉल्ट में सरणी में मर्ज कर दिया जाता है page.phpऔर index.php, टेम्प्लेट लोड करने से पहले 'template_redirect', लचीलापन जोड़ने और संगतता में सुधार करने के लिए।

उसके बाद, पाया गया टेम्पलेट कस्टम 'virtual_page_template'और कोर 'template_include'फिल्टर से गुजरता है : फिर से लचीलापन और संगतता के लिए।

अंत में टेम्पलेट फ़ाइल बस भरी हुई है।

मुख्य प्लगइन फ़ाइल

इस बिंदु पर हमें प्लगइन हेडर के साथ फाइल लिखने की जरूरत है और इसे जोड़ने के लिए हुक का उपयोग करें जो हमारे वर्कफ़्लो को बना देगा:

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

वास्तविक फ़ाइल में हम शायद अधिक हेडर जोड़ेंगे, जैसे प्लगइन और लेखक लिंक, विवरण, लाइसेंस, आदि।

प्लगिन जिस्ट

ठीक है, हम अपने प्लगइन के साथ किया जाता है। सभी कोड यहां एक जिस्ट में मिल सकते हैं ।

पेज जोड़ना

प्लगइन तैयार है और काम कर रहा है, लेकिन हमने कोई पृष्ठ नहीं जोड़ा है।

कि प्लगइन के अंदर ही किया जा सकता है, अंदर विषय functions.php, एक अन्य प्लगइन में, आदि।

पृष्ठों को जोड़ना केवल एक बात है:

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

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

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

} );

और इसी तरह। आप अपनी ज़रूरत के सभी पेज जोड़ सकते हैं, बस पृष्ठों के लिए सापेक्ष URL का उपयोग करना याद रखें।

टेम्प्लेट फ़ाइल के अंदर आप सभी वर्डप्रेस टेम्प्लेट टैग का उपयोग कर सकते हैं, और आप अपनी ज़रूरत के सभी पीएचपी और एचटीएमएल लिख सकते हैं।

वैश्विक पोस्ट ऑब्जेक्ट हमारे वर्चुअल पेज से आने वाले डेटा से भरा है। वर्चुअल पेज को ही $wp_query->virtual_pageवेरिएबल के जरिए एक्सेस किया जा सकता है ।

वर्चुअल पेज के लिए URL प्राप्त करना उतना ही आसान है जितना home_url()कि पेज बनाने के लिए उसी पथ पर जाना:

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

ध्यान दें कि लोड किए गए टेम्पलेट में मुख्य लूप में, the_permalink()वर्चुअल पेज पर सही पर्मलिंक लौटाएगा।

आभासी पृष्ठों के लिए शैलियों / लिपियों पर नोट्स

संभवतया जब वर्चुअल पेज जोड़े जाते हैं, तो कस्टम स्टाइल / स्क्रिप्ट्स को संलग्न करना और फिर wp_head()कस्टम टेम्पलेट में उपयोग करना भी वांछनीय है ।

यह बहुत आसान है, क्योंकि वर्चुअल पेज आसानी से $wp_query->virtual_pageवेरिएबल को देखते हुए पहचाने जाते हैं और वर्चुअल पेज अपने URL को देखने वाले से अलग पहचाने जा सकते हैं।

बस एक उदाहरण:

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

} );

ओपी को नोट्स

एक पृष्ठ से दूसरे में डेटा पास करना इन आभासी पृष्ठों से संबंधित नहीं है, लेकिन यह केवल एक सामान्य कार्य है।

हालाँकि, यदि आपके पास पहले पृष्ठ में एक फॉर्म है, और वहाँ से डेटा को दूसरे पेज पर भेजना चाहते हैं, तो बस फॉर्म में दूसरे पेज के URL का उपयोग actionप्रॉपर्टी के रूप में करें।

पहले पृष्ठ टेम्पलेट फ़ाइल में आप कर सकते हैं:

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

और फिर दूसरे पेज टेम्पलेट फ़ाइल में:

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

Comments

अद्भुत व्यापक जवाब, न केवल समस्या पर, बल्कि एक OOP शैली प्लग-इन और अधिक बनाने पर। आपने मेरे उत्थान के लिए सुनिश्चित किया, अधिक कल्पना करें, हर स्तर के उत्तर कवर के लिए एक।

— निकोलई

बहुत चालाक और सीधे आगे समाधान। अपडेट किया गया, ट्वीट किया गया।

— kaiser

नियंत्रक में कोड थोड़ा गलत है ... checkRequest () home_url () से स्थानीय जानकारी पा रहा है, जो लोकलहोस्ट / वर्डप्रेस देता है। Preg_replace और add_query_arg के बाद, यह url / वर्डप्रेस / वर्चुअल-पेज बन जाता है। और checkRequest में ट्रिम के बाद यह url वर्डप्रेस / वर्चुअल है। यह काम करेगा अगर वर्डप्रेस को डोमेन के रूट फ़ोल्डर में स्थापित किया जाएगा। क्या आप कृपया उस समस्या के लिए समाधान प्रदान कर सकते हैं क्योंकि मुझे उचित फ़ंक्शन नहीं मिल रहा है जो सही url लौटाएगा। हरचीज के लिए धन्यवाद! (मैं सही होने के बाद उत्तर स्वीकार कर लूंगा :)

— user1257255

बधाई, अच्छा जवाब और मुझे बहुत सारे काम मुफ्त समाधान के रूप में देखने की जरूरत है।

— बुलेट

@GM: मेरे मामले में वर्डप्रेस ... / htdocs / wordpress / में स्थापित है और साइट लोकलहोस्ट / वर्डप्रेस पर उपलब्ध है । home_url () स्थानीय होस्ट / वर्डप्रेस और add_query_arg (सरणी ()) रिटर्न / वर्डप्रेस / वर्चुअल-पेज / देता है। जब हम $ पथ की तुलना कर रहे हैं और इस $ को ट्रिम कर दिया है-> पेज-> करंट () -> getUrl () इन चेकअर्सपेस्ट () समस्या है क्योंकि $ पथ है wordpress/virtual-pageऔर पृष्ठ का ट्रिम यूआरएल है virtual-page।

— user1257255

Answer 2

मैंने एक बार यहां वर्णित एक समाधान का उपयोग किया था: http://scott.sherrillmix.com/blog/blogger/creating-a-better-fake-post-with-a-wordpress-plugin/

दरअसल, जब मैं इसका उपयोग कर रहा था, तो मैं इस तरह से समाधान का विस्तार करता हूं कि मैं एक समय में एक से अधिक पृष्ठ पंजीकृत कर सकता हूं (बाकी कोड +/- जैसा समाधान मैं ऊपर एक पैराग्राफ से लिंक कर रहा हूं)।

समाधान के लिए आवश्यक है कि आप अच्छे पर्मलिंक की अनुमति दें ...

<?php

class FakePages {

    public function __construct() {
        add_filter( 'the_posts', array( $this, 'fake_pages' ) );
    }

    /**
     * Internally registers pages we want to fake. Array key is the slug under which it is being available from the frontend
     * @return mixed
     */
    private static function get_fake_pages() {
        //http://example.com/fakepage1
        $fake_pages['fakepage1'] = array(
            'title'   => 'Fake Page 1',
            'content' => 'This is a content of fake page 1'
        );
        //http://example.com/fakepage2
        $fake_pages['fakepage2'] = array(
            'title'   => 'Fake Page 2',
            'content' => 'This is a content of fake page 2'
        );

        return $fake_pages;
    }

    /**
     * Fakes get posts result
     *
     * @param $posts
     *
     * @return array|null
     */
    public function fake_pages( $posts ) {
        global $wp, $wp_query;
        $fake_pages       = self::get_fake_pages();
        $fake_pages_slugs = array();
        foreach ( $fake_pages as $slug => $fp ) {
            $fake_pages_slugs[] = $slug;
        }
        if ( true === in_array( strtolower( $wp->request ), $fake_pages_slugs )
             || ( true === isset( $wp->query_vars['page_id'] )
                  && true === in_array( strtolower( $wp->query_vars['page_id'] ), $fake_pages_slugs )
            )
        ) {
            if ( true === in_array( strtolower( $wp->request ), $fake_pages_slugs ) ) {
                $fake_page = strtolower( $wp->request );
            } else {
                $fake_page = strtolower( $wp->query_vars['page_id'] );
            }
            $posts                  = null;
            $posts[]                = self::create_fake_page( $fake_page, $fake_pages[ $fake_page ] );
            $wp_query->is_page      = true;
            $wp_query->is_singular  = true;
            $wp_query->is_home      = false;
            $wp_query->is_archive   = false;
            $wp_query->is_category  = false;
            $wp_query->is_fake_page = true;
            $wp_query->fake_page    = $wp->request;
            //Longer permalink structures may not match the fake post slug and cause a 404 error so we catch the error here
            unset( $wp_query->query["error"] );
            $wp_query->query_vars["error"] = "";
            $wp_query->is_404              = false;
        }

        return $posts;
    }

    /**
     * Creates virtual fake page
     *
     * @param $pagename
     * @param $page
     *
     * @return stdClass
     */
    private static function create_fake_page( $pagename, $page ) {
        $post                 = new stdClass;
        $post->post_author    = 1;
        $post->post_name      = $pagename;
        $post->guid           = get_bloginfo( 'wpurl' ) . '/' . $pagename;
        $post->post_title     = $page['title'];
        $post->post_content   = $page['content'];
        $post->ID             = - 1;
        $post->post_status    = 'static';
        $post->comment_status = 'closed';
        $post->ping_status    = 'closed';
        $post->comment_count  = 0;
        $post->post_date      = current_time( 'mysql' );
        $post->post_date_gmt  = current_time( 'mysql', 1 );

        return $post;
    }
}

new FakePages();

Comments

कस्टम टेम्पलेट के बारे में क्या मैं अपना फ़ॉर्म रख सकता / सकती हूँ?

— user1257255

contentसरणी में जब आप फर्जी पेज रजिस्टर कर रहे हैं तो पेज के मुख्य भाग में प्रदर्शित किया जा रहा है - इसमें HTML के साथ-साथ सरल पाठ या एक शोर्ट भी हो सकता है।

— david.binda