पुनर्व्यवस्थित URL का निर्माण करने के लिए रिवाइटर एपीआई का उपयोग करना


19

मैं एक RESTful API के लिए फिर से लिखना नियम बनाने की कोशिश कर रहा हूं। मैं बस यह देखना चाहता हूं कि क्या इस काम को करने के लिए हर संभव पुनर्लेखन संयोजन को लिखने से बेहतर तरीका है।

ठीक है, तो मेरे पास URL में खाते के लिए 4 क्वेरी चर हैं

  • सूचक
  • देश
  • प्रतिक्रिया
  • सर्वेक्षण

आधार यूआरएल www.example.com/some-page/ होगा 4 चर का क्रम सुसंगत होगा लेकिन कुछ क्वेरी चर वैकल्पिक हैं।

तो मैं कर सकता था ...

/indicator/{indicator value}/country/{country value}/response/{response value}/survey/{survey value}/

या ... (नहीं / प्रतिक्रिया /)

/indicator/{indicator value}/country/{country value}/survey/{survey value}/

या ...

/indicator/{indicator value}/country/{country value}/

क्या इसे फ़िल्टर करने rewrite_rules_arrayऔर मेरे पुनर्लेखन नियमों की एक सरणी को मैन्युअल रूप से बनाए जाने की तुलना में पूरा करने का एक बेहतर तरीका है ? क्या add_rewrite_endpoint()rewrite_endpoint या add_rewrite_tag()मेरे लिए कोई उपयोग होगा?

जवाबों:


18

मुझे लगता है कि सबसे अच्छा विकल्प एक समापन बिंदु है। आपको एक साधारण स्ट्रिंग के रूप में सभी डेटा मिलते हैं, इसलिए आप यह तय कर सकते हैं कि इसे कैसे पार्स किया जाएगा, और आपको अन्य रीराइट नियमों के साथ टकराव के बारे में चिंता करने की ज़रूरत नहीं है।

एक बात जो मैंने समापन बिंदुओं के बारे में सीखी: मुख्य कार्य को यथासंभव सार में रखें, डेटा एग्रोस्टिक तरीके से वर्डप्रेस के एपीआई में गड़बड़ को ठीक करें।

मैं तर्क को तीन भागों में अलग करूंगा: एक नियंत्रक एक मॉडल और एक दृश्य का चयन करें, समापन बिंदु को संभालने के लिए एक मॉडल और कुछ उपयोगी डेटा या त्रुटि संदेशों को वापस करने के लिए एक या अधिक दृश्य

नियंत्रक

नियंत्रक के साथ शुरू करते हैं। यह बहुत कुछ नहीं करता है, इसलिए मैं यहां एक बहुत ही सरल फ़ंक्शन का उपयोग करता हूं:

add_action( 'plugins_loaded', 't5_cra_init' );

function t5_cra_init()
{
    require dirname( __FILE__ ) . '/class.T5_CRA_Model.php';

    $options = array (
        'callback' => array ( 'T5_CRA_View_Demo', '__construct' ),
        'name'     => 'api',
        'position' => EP_ROOT
    );
    new T5_CRA_Model( $options );
}

असल में, यह मॉडल को लोड करता है T5_CRA_Modelऔर कुछ मापदंडों पर काम करता है ... और सभी काम। नियंत्रक को मॉडल या दृश्य के आंतरिक तर्क के बारे में कुछ भी पता नहीं है। यह बस एक साथ दोनों चिपक जाती है। यह एकमात्र हिस्सा है जिसका आप पुन: उपयोग नहीं कर सकते हैं; इसलिए मैंने इसे अन्य भागों से अलग रखा।


अब हमें कम से कम दो वर्गों की आवश्यकता है: मॉडल जो एपीआई और उत्पादन बनाने के दृष्टिकोण को पंजीकृत करता है ।

आदर्श

यह वर्ग होगा:

  • समापन बिंदु पंजीकृत करें
  • उन मामलों को पकड़ें जहां किसी अतिरिक्त पैरामीटर के बिना समापन बिंदु कहा जाता था
  • थर्ड पार्टी कोड में कुछ बग्स के कारण छूटे हुए नियमों को फिर से भरें
  • स्थिर सामने पृष्ठों और समापन बिंदु के साथ एक वर्डप्रेस गड़बड़ को ठीक करें EP_ROOT
  • URI को एक सरणी में विभाजित करें (इसे अलग भी किया जा सकता है)
  • उन मूल्यों के साथ कॉलबैक हैंडलर को कॉल करें

मुझे उम्मीद है कि कोड खुद के लिए बोलता है। :)

मॉडल डेटा की आंतरिक संरचना या प्रस्तुति के बारे में कुछ भी नहीं जानता है। तो आप एक लाइन को बदले बिना सैकड़ों APIs पंजीकृत करने के लिए इसका उपयोग कर सकते हैं।

<?php  # -*- coding: utf-8 -*-
/**
 * Register new REST API as endpoint.
 *
 * @author toscho http://toscho.de
 *
 */
class T5_CRA_Model
{
    protected $options;

    /**
     * Read options and register endpoint actions and filters.
     *
     * @wp-hook plugins_loaded
     * @param   array $options
     */
    public function __construct( Array $options )
    {
        $default_options = array (
            'callback' => array ( 'T5_CRA_View_Demo', '__construct' ),
            'name'     => 'api',
            'position' => EP_ROOT
        );

        $this->options = wp_parse_args( $options, $default_options );

        add_action( 'init', array ( $this, 'register_api' ), 1000 );

        // endpoints work on the front end only
        if ( is_admin() )
            return;

        add_filter( 'request', array ( $this, 'set_query_var' ) );
        // Hook in late to allow other plugins to operate earlier.
        add_action( 'template_redirect', array ( $this, 'render' ), 100 );
    }

    /**
     * Add endpoint and deal with other code flushing our rules away.
     *
     * @wp-hook init
     * @return void
     */
    public function register_api()
    {
        add_rewrite_endpoint(
            $this->options['name'],
            $this->options['position']
        );
        $this->fix_failed_registration(
            $this->options['name'],
            $this->options['position']
        );
    }

    /**
     * Fix rules flushed by other peoples code.
     *
     * @wp-hook init
     * @param string $name
     * @param int    $position
     */
    protected function fix_failed_registration( $name, $position )
    {
        global $wp_rewrite;

        if ( empty ( $wp_rewrite->endpoints ) )
            return flush_rewrite_rules( FALSE );

        foreach ( $wp_rewrite->endpoints as $endpoint )
            if ( $endpoint[0] === $position && $endpoint[1] === $name )
                return;

        flush_rewrite_rules( FALSE );
    }

    /**
     * Set the endpoint variable to TRUE.
     *
     * If the endpoint was called without further parameters it does not
     * evaluate to TRUE otherwise.
     *
     * @wp-hook request
     * @param   array $vars
     * @return  array
     */
    public function set_query_var( Array $vars )
    {
        if ( ! empty ( $vars[ $this->options['name'] ] ) )
            return $vars;

        // When a static page was set as front page, the WordPress endpoint API
        // does some strange things. Let's fix that.
        if ( isset ( $vars[ $this->options['name'] ] )
            or ( isset ( $vars['pagename'] ) and $this->options['name'] === $vars['pagename'] )
            or ( isset ( $vars['page'] ) and $this->options['name'] === $vars['name'] )
            )
        {
            // In some cases WP misinterprets the request as a page request and
            // returns a 404.
            $vars['page'] = $vars['pagename'] = $vars['name'] = FALSE;
            $vars[ $this->options['name'] ] = TRUE;
        }
        return $vars;
    }

    /**
     * Prepare API requests and hand them over to the callback.
     *
     * @wp-hook template_redirect
     * @return  void
     */
    public function render()
    {
        $api = get_query_var( $this->options['name'] );
        $api = trim( $api, '/' );

        if ( '' === $api )
            return;

        $parts  = explode( '/', $api );
        $type   = array_shift( $parts );
        $values = $this->get_api_values( join( '/', $parts ) );
        $callback = $this->options['callback'];

        if ( is_string( $callback ) )
        {
            call_user_func( $callback, $type, $values );
        }
        elseif ( is_array( $callback ) )
        {
            if ( '__construct' === $callback[1] )
                new $callback[0]( $type, $values );
            elseif ( is_callable( $callback ) )
                call_user_func( $callback, $type, $values );
        }
        else
        {
            trigger_error(
                'Cannot call your callback: ' . var_export( $callback, TRUE ),
                E_USER_ERROR
            );
        }

        // Important. WordPress will render the main page if we leave this out.
        exit;
    }

    /**
     * Parse request URI into associative array.
     *
     * @wp-hook template_redirect
     * @param   string $request
     * @return  array
     */
    protected function get_api_values( $request )
    {
        $keys    = $values = array();
        $count   = 0;
        $request = trim( $request, '/' );
        $tok     = strtok( $request, '/' );

        while ( $tok !== FALSE )
        {
            0 === $count++ % 2 ? $keys[] = $tok : $values[] = $tok;
            $tok = strtok( '/' );
        }

        // fix odd requests
        if ( count( $keys ) !== count( $values ) )
            $values[] = '';

        return array_combine( $keys, $values );
    }
}

दृश्य

अब हमें अपने डेटा के साथ कुछ करना होगा। हम अपूर्ण अनुरोधों के लिए लापता डेटा को भी पकड़ सकते हैं या अन्य विचारों या उप-नियंत्रकों से निपटने को सौंप सकते हैं।

यहाँ एक बहुत ही सरल उदाहरण दिया गया है:

class T5_CRA_View_Demo
{
    protected $allowed_types = array (
            'plain',
            'html',
            'xml'
    );

    protected $default_values = array (
        'country' => 'Norway',
        'date'    => 1700,
        'max'     => 200
    );
    public function __construct( $type, $data )
    {
        if ( ! in_array( $type, $this->allowed_types ) )
            die( 'Your request is invalid. Please read our fantastic manual.' );

        $data = wp_parse_args( $data, $this->default_values );

        header( "Content-Type: text/$type;charset=utf-8" );
        $method = "render_$type";
        $this->$method( $data );
    }

    protected function render_plain( $data )
    {
        foreach ( $data as $key => $value )
            print "$key: $value\n";
    }
    protected function render_html( $data ) {}
    protected function render_xml( $data ) {}
}

महत्वपूर्ण हिस्सा है: दृश्य समापन बिंदु के बारे में कुछ भी नहीं जानता है। आप इसका उपयोग पूरी तरह से अलग अनुरोधों को संभालने के लिए कर सकते हैं, उदाहरण के लिए AJAX के अनुरोध wp-admin। आप अपने स्वयं के MVC पैटर्न में दृश्य को विभाजित कर सकते हैं या बस एक साधारण फ़ंक्शन का उपयोग कर सकते हैं।


2
अंक। मुझे इस तरह का पैटर्न पसंद है।
किंगकुले 68
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.