वेबसाइट के सामने अंत में वर्डप्रेस उपयोगकर्ता पंजीकरण फॉर्म कैसे प्रदर्शित करें?


30

मेरे ब्लॉग के सामने के अंत में वर्डप्रेस उपयोगकर्ता पंजीकरण फॉर्म ("www.mywebsite.com/wp-register.php" पृष्ठ पर दिखाई देने वाला फ़ॉर्म) कैसे प्रदर्शित किया जाए?

मैंने पंजीकरण फॉर्म को अनुकूलित कर लिया है। लेकिन सामने वाले पेज में उस फॉर्म को कॉल करना नहीं जानते। किसी भी सहायता वास्तव में बहुत मदद मिलेगी।

अग्रिम में धन्यवाद। :)


सबसे अच्छा समाधान मैंने पाया है थीम मेरा लॉगिन प्लगइन
wyrfel

यह आलेख आपको अपने स्वयं के फ्रंटेंड रजिस्टर / लॉगिन / पासवर्ड फॉर्म को पुनर्स्थापित करने के तरीके के बारे में एक बढ़िया ट्यूटोरियल प्रदान करता है। या यदि आप एक प्लगइन की तलाश कर रहे हैं, तो मैंने पहले इनका उपयोग किया है और उन्हें पुनः प्राप्त कर सकता हूं: - Ajax लॉगिन / रजिस्टर - Ajax के साथ लॉगिन
Bainternet

कॉस्मोलैब से क्रिस्टियन ने स्रोत फ़ाइलों के साथ एक महान ट्यूटोरियल पोस्ट किया है जो आपको फ्रंट-एंड उपयोगकर्ता प्रोफ़ाइल, लॉगिन और रजिस्टर टेम्प्लेट बनाने की क्षमता देता है।
फिलिप

जवाबों:


33

प्रक्रिया में 2 चरण शामिल हैं:

  1. सामने का रूप दिखाएं
  2. डेटा सबमिट करने पर सेव करें

3 अलग-अलग दृष्टिकोण हैं जो मेरे दिमाग में सामने वाले को दिखाने के लिए आते हैं:

  • इसे अधिक "फ्रंटएंड" बनाने के लिए बिल्ट-इन रजिस्ट्रेशन फॉर्म, एडिटिंग स्टाइल आदि का उपयोग करें।
  • एक वर्डप्रेस पृष्ठ / पोस्ट का उपयोग करें, और एक शोर्ट का उपयोग करके प्रदर्शन फ़ॉर्म
  • एक समर्पित टेम्पलेट का उपयोग किसी भी पृष्ठ / पोस्ट से जुड़ा नहीं है, लेकिन एक विशिष्ट यूआरएल द्वारा कहा जाता है

इस उत्तर के लिए मैं बाद का उपयोग करूँगा। कारण हैं:

  • बिल्ट-इन रजिस्ट्रेशन फॉर्म का उपयोग करना एक अच्छा विचार हो सकता है, गहरे कस्टमाइज़ेशन बिल्ट-इन फॉर्म का उपयोग करके बहुत कठिन हो सकते हैं, और यदि कोई कस्टमाइज़ करना चाहता है तो दर्द को बढ़ा सकता है।
  • एक शोर्टकोड के साथ संयोजन में एक वर्डप्रेस पेज का उपयोग करें, इतना विश्वसनीय नहीं है, और मुझे यह भी लगता है कि शोर्टकोड का उपयोग कार्यक्षमता के लिए नहीं किया जाना चाहिए, बस स्वरूपण और इस तरह के लिए

1: यूआरएल का निर्माण

हम सभी जानते हैं कि वर्डप्रेस साइट का डिफ़ॉल्ट पंजीकरण फॉर्म अक्सर स्पैमर्स के लिए एक लक्ष्य है। कस्टम url का उपयोग इस समस्या को हल करने में मदद करता है। इसके अलावा, मैं एक चर url का उपयोग करना चाहता हूं , अर्थात पंजीकरण फॉर्म url हमेशा समान नहीं होना चाहिए, इससे स्पैमर्स का जीवन कठिन हो जाता है। चाल url में एक गैर का उपयोग करके किया जाता है :

/**
* Generate dynamic registration url
*/
function custom_registration_url() {
  $nonce = urlencode( wp_create_nonce( 'registration_url' ) );
  return home_url( $nonce );
}

/**
* Generate dynamic registration link
*/
function custom_registration_link() {
  $format = '<a href="%s">%s</a>';
  printf(
    $format,
    custom_registration_url(), __( 'Register', 'custom_reg_form' )
  );
}

इस फ़ंक्शंस का उपयोग करना टेम्प्लेट में प्रदर्शित करना आसान है, भले ही यह गतिशील हो, पंजीकरण फ़ॉर्म का लिंक।

2: url को पहचानें, Custom_Reg\Custom_Regकक्षा का पहला स्टब

अब हमें url को पहचानने की आवश्यकता है। इस प्रस्ताव के लिए मैं एक कक्षा लिखना शुरू करूँगा, जो उत्तर में बाद में समाप्त होगी:

<?php
// don't save, just a stub
namespace Custom_Reg;

class Custom_Reg {

  function checkUrl() {
    $url_part = $this->getUrl();
    $nonce = urlencode( wp_create_nonce( 'registration_url' ) );
    if ( ( $url_part === $nonce ) ) {
      // do nothing if registration is not allowed or user logged
      if ( is_user_logged_in() || ! get_option('users_can_register') ) {
        wp_safe_redirect( home_url() );
        exit();
      }
      return TRUE;
    }
  }

  protected function getUrl() {
    $home_path = trim( parse_url( home_url(), PHP_URL_PATH ), '/' );
    $relative = trim(str_replace($home_path, '', esc_url(add_query_arg(array()))), '/');
    $parts = explode( '/', $relative );
    if ( ! empty( $parts ) && ! isset( $parts[1] ) ) {
      return $parts[0];
    }
  }

}

फ़ंक्शन url के पहले भाग को देखता है home_url(), और यदि यह हमारे नॉन से मेल खाता है तो यह TRUE पर लौटता है। यह फ़ंक्शन हमारे अनुरोध की जांच करने और हमारे फ़ॉर्म को प्रदर्शित करने के लिए आवश्यक कार्रवाई करने के लिए उपयोग किया जाएगा।

3: Custom_Reg\Formवर्ग

अब मैं एक क्लास लिखूंगा, जो फॉर्म मार्कअप जनरेट करने के लिए जिम्मेदार होगा। मैं इसे एक संपत्ति में स्टोर करने के लिए उपयोग करूँगा टेम्पलेट फ़ाइल पथ जिसे फ़ॉर्म प्रदर्शित करने के लिए उपयोग किया जाना चाहिए।

<?php 
// file: Form.php
namespace Custom_Reg;

class Form {

  protected $fields;

  protected $verb = 'POST';

  protected $template;

  protected $form;

  public function __construct() {
    $this->fields = new \ArrayIterator();
  }

  public function create() {
    do_action( 'custom_reg_form_create', $this );
    $form = $this->open();
    $it =  $this->getFields();
    $it->rewind();
    while( $it->valid() ) {
      $field = $it->current();
      if ( ! $field instanceof FieldInterface ) {
        throw new \DomainException( "Invalid field" );
      }
      $form .= $field->create() . PHP_EOL;
      $it->next();
    }
    do_action( 'custom_reg_form_after_fields', $this );
    $form .= $this->close();
    $this->form = $form;
    add_action( 'custom_registration_form', array( $this, 'output' ), 0 );
  }

  public function output() {
    unset( $GLOBALS['wp_filters']['custom_registration_form'] );
    if ( ! empty( $this->form ) ) {
      echo $this->form;
    }
  }

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

  public function setTemplate( $template ) {
    if ( ! is_string( $template ) ) {
      throw new \InvalidArgumentException( "Invalid template" );
    }
    $this->template = $template;
  }

  public function addField( FieldInterface $field ) {
    $hook = 'custom_reg_form_create';
    if ( did_action( $hook ) && current_filter() !== $hook ) {
      throw new \BadMethodCallException( "Add fields before {$hook} is fired" );
    }
    $this->getFields()->append( $field );
  }

  public function getFields() {
    return $this->fields;
  }

  public function getVerb() {
    return $this->verb;
  }

  public function setVerb( $verb ) {
    if ( ! is_string( $verb) ) {
     throw new \InvalidArgumentException( "Invalid verb" );
    }
    $verb = strtoupper($verb);
    if ( in_array($verb, array( 'GET', 'POST' ) ) ) $this->verb = $verb;
  }

  protected function open() {
    $out = sprintf( '<form id="custom_reg_form" method="%s">', $this->verb ) . PHP_EOL;
    $nonce = '<input type="hidden" name="_n" value="%s" />';
    $out .= sprintf( $nonce,  wp_create_nonce( 'custom_reg_form_nonce' ) ) . PHP_EOL;
    $identity = '<input type="hidden" name="custom_reg_form" value="%s" />';
    $out .= sprintf( $identity,  __CLASS__ ) . PHP_EOL;
    return $out;
  }

  protected function close() {
    $submit =  __('Register', 'custom_reg_form');
    $out = sprintf( '<input type="submit" value="%s" />', $submit );
    $out .= '</form>';
    return $out;
  }

}

क्लास ने सभी क्षेत्रों को जोड़ने के लिए फार्म मार्कअप लूपिंग उत्पन्न की, createजिनमें से प्रत्येक पर कॉलिंग विधि भी शामिल है। प्रत्येक क्षेत्र का उदाहरण होना चाहिए Custom_Reg\FieldInterface। नॉन वेरिफिकेशन के लिए एक अतिरिक्त छिपा हुआ क्षेत्र जोड़ा जाता है। फॉर्म विधि डिफ़ॉल्ट रूप से 'POST' है, लेकिन इसे setVerbविधि का उपयोग करके 'GET' में निपटाया जा सकता है । एक बार बनाया गया मार्कअप $formऑब्जेक्ट ऑब्जेक्ट के अंदर सहेजा जाता है जिसे output()विधि द्वारा प्रतिध्वनित किया जाता है, हुक में 'custom_registration_form'हुक किया जाता है: फॉर्म टेम्पलेट में, बस कॉल do_action( 'custom_registration_form' )फॉर्म को आउटपुट करेगा।

4: डिफ़ॉल्ट टेम्पलेट

जैसा कि मैंने कहा कि फॉर्म के लिए टेम्प्लेट को आसानी से ओवरराइड किया जा सकता है, हालांकि हमें फॉलबैक के रूप में एक बुनियादी टेम्प्लेट की आवश्यकता होती है। मैंने यहाँ लिखा है एक बहुत ही कठिन टेम्पलेट, एक वास्तविक टेम्पलेट की तुलना में अवधारणा का प्रमाण अधिक है।

<?php
// file: default_form_template.php
get_header();

global $custom_reg_form_done, $custom_reg_form_error;

if ( isset( $custom_reg_form_done ) && $custom_reg_form_done ) {
  echo '<p class="success">';
  _e(
    'Thank you, your registration was submitted, check your email.',
    'custom_reg_form'
  );
  echo '</p>';
} else {
  if ( $custom_reg_form_error ) {
    echo '<p class="error">' . $custom_reg_form_error  . '</p>';
  }
  do_action( 'custom_registration_form' );
}

get_footer();

5: Custom_Reg\FieldInterfaceइंटरफ़ेस

प्रत्येक फ़ील्ड में एक ऑब्जेक्ट होना चाहिए जो निम्नलिखित इंटरफ़ेस को लागू करता है

<?php 
// file: FieldInterface.php
namespace Custom_Reg;

interface FieldInterface {

  /**
   * Return the field id, used to name the request value and for the 'name' param of
   * html input field
   */
  public function getId();

  /**
   * Return the filter constant that must be used with
   * filter_input so get the value from request
   */
  public function getFilter();

  /**
   * Return true if the used value passed as argument should be accepted, false if not
   */
  public function isValid( $value = NULL );

  /**
   * Return true if field is required, false if not
   */
  public function isRequired();

  /**
   * Return the field input markup. The 'name' param must be output 
   * according to getId()
   */
  public function create( $value = '');
}

मुझे लगता है कि टिप्पणियां बताती हैं कि इस इंटरफ़ेस को लागू करने वाले वर्गों को क्या करना चाहिए।

6: कुछ क्षेत्रों को जोड़ना

अब हमें कुछ क्षेत्रों की आवश्यकता है। हम एक फाइल बना सकते हैं, जिसे 'field.php' कहा जाता है, जहां हम फील्ड क्लासेस को परिभाषित करते हैं:

<?php
// file: fields.php
namespace Custom_Reg;

abstract class BaseField implements FieldInterface {

  protected function getType() {
    return isset( $this->type ) ? $this->type : 'text';
  }

  protected function getClass() {
    $type = $this->getType();
    if ( ! empty($type) ) return "{$type}-field";
  }

  public function getFilter() {
    return FILTER_SANITIZE_STRING;
  }

  public function isRequired() {
    return isset( $this->required ) ? $this->required : FALSE;
  }

  public function isValid( $value = NULL ) {
    if ( $this->isRequired() ) {
      return $value != '';
    }
    return TRUE;
  }

  public function create( $value = '' ) {
    $label = '<p><label>' . $this->getLabel() . '</label>';
    $format = '<input type="%s" name="%s" value="%s" class="%s"%s /></p>';
    $required = $this->isRequired() ? ' required' : '';
    return $label . sprintf(
      $format,
      $this->getType(), $this->getId(), $value, $this->getClass(), $required
    );
  }

  abstract function getLabel();
}


class FullName extends BaseField {

  protected $required = TRUE;

  public function getID() {
    return 'fullname';
  }

  public function getLabel() {
    return __( 'Full Name', 'custom_reg_form' );
  }

}

class Login extends BaseField {

  protected $required = TRUE;

  public function getID() {
    return 'login';
  }

  public function getLabel() {
    return __( 'Username', 'custom_reg_form' );
  }
}

class Email extends BaseField {

  protected $type = 'email';

  public function getID() {
    return 'email';
  }

  public function getLabel() {
    return __( 'Email', 'custom_reg_form' );
  }

  public function isValid( $value = NULL ) {
    return ! empty( $value ) && filter_var( $value, FILTER_VALIDATE_EMAIL );
  }
}

class Country extends BaseField {

  protected $required = FALSE;

  public function getID() {
    return 'country';
  }

  public function getLabel() {
    return __( 'Country', 'custom_reg_form' );
  }
}

मैंने डिफॉल्ट इंटरफ़ेस इम्प्लिमेंटेशन को परिभाषित करने के लिए बेस क्लास का उपयोग किया है, हालाँकि, कोई बहुत ही कस्टमाइज़्ड फ़ील्ड को सीधे इंटरफ़ेस को लागू कर सकता है या बेस क्लास को बढ़ा सकता है और कुछ तरीकों को ओवरराइड कर सकता है।

इस बिंदु पर हमारे पास फ़ॉर्म प्रदर्शित करने के लिए सब कुछ है, अब हमें फ़ील्ड को सत्यापित करने और सहेजने के लिए कुछ चाहिए।

7: Custom_Reg\Saverवर्ग

<?php
// file: Saver.php
namespace Custom_Reg;

class Saver {

  protected $fields;

  protected $user = array( 'user_login' => NULL, 'user_email' => NULL );

  protected $meta = array();

  protected $error;

  public function setFields( \ArrayIterator $fields ) {
    $this->fields = $fields;
  }

  /**
  * validate all the fields
  */
  public function validate() {
    // if registration is not allowed return false
    if ( ! get_option('users_can_register') ) return FALSE;
    // if no fields are setted return FALSE
    if ( ! $this->getFields() instanceof \ArrayIterator ) return FALSE;
    // first check nonce
    $nonce = $this->getValue( '_n' );
    if ( $nonce !== wp_create_nonce( 'custom_reg_form_nonce' ) ) return FALSE;
    // then check all fields
    $it =  $this->getFields();
    while( $it->valid() ) {
      $field = $it->current();
      $key = $field->getID();
      if ( ! $field instanceof FieldInterface ) {
        throw new \DomainException( "Invalid field" );
      }
      $value = $this->getValue( $key, $field->getFilter() );
      if ( $field->isRequired() && empty($value) ) {
        $this->error = sprintf( __('%s is required', 'custom_reg_form' ), $key );
        return FALSE;
      }
      if ( ! $field->isValid( $value ) ) {
        $this->error = sprintf( __('%s is not valid', 'custom_reg_form' ), $key );
        return FALSE;
      }
      if ( in_array( "user_{$key}", array_keys($this->user) ) ) {
        $this->user["user_{$key}"] = $value;
      } else {
        $this->meta[$key] = $value;
      }
      $it->next();
    }
    return TRUE;
  }

  /**
  * Save the user using core register_new_user that handle username and email check
  * and also sending email to new user
  * in addition save all other custom data in user meta
  *
  * @see register_new_user()
  */
  public function save() {
    // if registration is not allowed return false
    if ( ! get_option('users_can_register') ) return FALSE;
    // check mandatory fields
    if ( ! isset($this->user['user_login']) || ! isset($this->user['user_email']) ) {
      return false;
    }
    $user = register_new_user( $this->user['user_login'], $this->user['user_email'] );
    if ( is_numeric($user) ) {
      if ( ! update_user_meta( $user, 'custom_data', $this->meta ) ) {
        wp_delete_user($user);
        return FALSE;
      }
      return TRUE;
    } elseif ( is_wp_error( $user ) ) {
      $this->error = $user->get_error_message();
    }
    return FALSE;
  }

  public function getValue( $var, $filter = FILTER_SANITIZE_STRING ) {
    if ( ! is_string($var) ) {
      throw new \InvalidArgumentException( "Invalid value" );
    }
    $method = strtoupper( filter_input( INPUT_SERVER, 'REQUEST_METHOD' ) );
    $type = $method === 'GET' ? INPUT_GET : INPUT_POST;
    $val = filter_input( $type, $var, $filter );
    return $val;
  }

  public function getFields() {
    return $this->fields;
  }

  public function getErrorMessage() {
    return $this->error;
  }

}

उस वर्ग में, 2 मुख्य विधियाँ हैं, एक ( validate) जो खेतों को लूप करती है, उन्हें मान्य करती है और एक सरणी में अच्छे डेटा को सहेजती है, दूसरी ( save) डेटाबेस में सभी डेटा को सहेजती है और नए उपयोगकर्ता को ईमेल के माध्यम से पासवर्ड भेजती है।

8: परिभाषित कक्षाओं का उपयोग करना: Custom_Regकक्षा को पूरा करना

अब हम Custom_Regकक्षा पर फिर से काम कर सकते हैं , उन तरीकों को जोड़ सकते हैं जो परिभाषित की गई वस्तुओं को "glues" करते हैं और उन्हें काम करते हैं

<?php 
// file Custom_Reg.php
namespace Custom_Reg;

class Custom_Reg {

  protected $form;

  protected $saver;

  function __construct( Form $form, Saver $saver ) {
    $this->form = $form;
    $this->saver = $saver;
  }

  /**
   * Check if the url to recognize is the one for the registration form page
   */
  function checkUrl() {
    $url_part = $this->getUrl();
    $nonce = urlencode( wp_create_nonce( 'registration_url' ) );
    if ( ( $url_part === $nonce ) ) {
      // do nothing if registration is not allowed or user logged
      if ( is_user_logged_in() || ! get_option('users_can_register') ) {
        wp_safe_redirect( home_url() );
        exit();
      }
      return TRUE;
    }
  }

  /**
   * Init the form, if submitted validate and save, if not just display it
   */
  function init() {
    if ( $this->checkUrl() !== TRUE ) return;
    do_action( 'custom_reg_form_init', $this->form );
    if ( $this->isSubmitted() ) {
      $this->save();
    }
    // don't need to create form if already saved
    if ( ! isset( $custom_reg_form_done ) || ! $custom_reg_form_done ) {
      $this->form->create();
    }
    load_template( $this->getTemplate() );
    exit();
  }

  protected function save() {
    global $custom_reg_form_error;
    $this->saver->setFields( $this->form->getFields() );
    if ( $this->saver->validate() === TRUE ) { // validate?
      if ( $this->saver->save() ) { // saved?
        global $custom_reg_form_done;
        $custom_reg_form_done = TRUE;
      } else { // saving error
        $err =  $this->saver->getErrorMessage(); 
        $custom_reg_form_error = $err ? : __( 'Error on save.', 'custom_reg_form' );
      }
    } else { // validation error
       $custom_reg_form_error = $this->saver->getErrorMessage();
    }
  }

  protected function isSubmitted() {
    $type = $this->form->getVerb() === 'GET' ? INPUT_GET : INPUT_POST;
    $sub = filter_input( $type, 'custom_reg_form', FILTER_SANITIZE_STRING );
    return ( ! empty( $sub ) && $sub === get_class( $this->form ) );
  }

  protected function getTemplate() {
    $base = $this->form->getTemplate() ? : FALSE;
    $template = FALSE;
    $default = dirname( __FILE__ ) . '/default_form_template.php';
    if ( ! empty( $base ) ) {
      $template = locate_template( $base );
    }
    return $template ? : $default;
  }

   protected function getUrl() {
    $home_path = trim( parse_url( home_url(), PHP_URL_PATH ), '/' );
    $relative = trim( str_replace( $home_path, '', add_query_arg( array() ) ), '/' );
    $parts = explode( '/', $relative );
    if ( ! empty( $parts ) && ! isset( $parts[1] ) ) {
      return $parts[0];
    }
  }

}

कक्षा का निर्माणकर्ता एक उदाहरण को स्वीकार करता Formहै Saver

init()विधि (का उपयोग करके checkUrl()) के बाद url के पहले भाग को देखें home_url(), और यदि यह सही गैर के साथ मेल खाता है, तो यह जाँचता है कि क्या फॉर्म पहले ही सबमिट किया गया था, यदि ऐसा है तो Saverऑब्जेक्ट का उपयोग करते हुए , यह उपयोगकर्ता नाम को सत्यापित और सहेजता है, अन्यथा बस फॉर्म को प्रिंट करें ।

init()विधि 'custom_reg_form_init'प्रपत्र आवृत्ति को तर्क के रूप में पास करने वाले एक्शन हुक को भी आग लगाती है: इस हुक का उपयोग फ़ील्ड जोड़ने के लिए, कस्टम टेम्पलेट को सेटअप करने के लिए और फॉर्म विधि को अनुकूलित करने के लिए भी किया जाना चाहिए।

9: चीजों को एक साथ रखना

अब हमें मुख्य प्लगइन फाइल लिखने की आवश्यकता है, जहां हम कर सकते हैं

  • सभी फ़ाइलों की आवश्यकता है
  • टेक्सटोमैन को लोड करें
  • तत्काल पूरी तरह से हुक का उपयोग करके इस पर तत्काल Custom_Regवर्ग और कॉल init()विधि का उपयोग करके स्टार्टअप पूरी प्रक्रिया
  • फ़ील्ड बनाने के लिए फ़ील्ड जोड़ने के लिए 'custom_reg_form_init' का उपयोग करें

इसलिए:

<?php 
/**
 * Plugin Name: Custom Registration Form
 * Description: Just a rough plugin example to answer a WPSE question
 * Plugin URI: https://wordpress.stackexchange.com/questions/10309/
 * Author: G. M.
 * Author URI: https://wordpress.stackexchange.com/users/35541/g-m
 *
 */

if ( is_admin() ) return; // this plugin is all about frontend

load_plugin_textdomain(
  'custom_reg_form',
  FALSE,
  plugin_dir_path( __FILE__ ) . 'langs'
); 

require_once plugin_dir_path( __FILE__ ) . 'FieldInterface.php';
require_once plugin_dir_path( __FILE__ ) . 'fields.php';
require_once plugin_dir_path( __FILE__ ) . 'Form.php';
require_once plugin_dir_path( __FILE__ ) . 'Saver.php';
require_once plugin_dir_path( __FILE__ ) . 'CustomReg.php';

/**
* Generate dynamic registration url
*/
function custom_registration_url() {
  $nonce = urlencode( wp_create_nonce( 'registration_url' ) );
  return home_url( $nonce );
}

/**
* Generate dynamic registration link
*/
function custom_registration_link() {
  $format = '<a href="%s">%s</a>';
  printf(
    $format,
    custom_registration_url(), __( 'Register', 'custom_reg_form' )
  );
}

/**
* Setup, show and save the form
*/
add_action( 'wp_loaded', function() {
  try {
    $form = new Custom_Reg\Form;
    $saver = new Custom_Reg\Saver;
    $custom_reg = new Custom_Reg\Custom_Reg( $form, $saver );
    $custom_reg->init();
  } catch ( Exception $e ) {
    if ( defined('WP_DEBUG') && WP_DEBUG ) {
      $msg = 'Exception on  ' . __FUNCTION__;
      $msg .= ', Type: ' . get_class( $e ) . ', Message: ';
      $msg .= $e->getMessage() ? : 'Unknown error';
      error_log( $msg );
    }
    wp_safe_redirect( home_url() );
  }
}, 0 );

/**
* Add fields to form
*/
add_action( 'custom_reg_form_init', function( $form ) {
  $classes = array(
    'Custom_Reg\FullName',
    'Custom_Reg\Login',
    'Custom_Reg\Email',
    'Custom_Reg\Country'
  );
  foreach ( $classes as $class ) {
    $form->addField( new $class );
  }
}, 1 );

10: लापता कार्य

अब हमेशा के लिए किया जाता है। हमें बस टेम्पलेट को कस्टमाइज़ करना है, शायद हमारे विषय में एक कस्टम टेम्पलेट फ़ाइल जोड़ना है।

हम इस तरह से केवल विशिष्ट पंजीकरण पृष्ठ पर विशिष्ट शैलियों और लिपियों को जोड़ सकते हैं

add_action( 'wp_enqueue_scripts', function() {
  // if not on custom registration form do nothing
  if ( did_action('custom_reg_form_init') ) {
    wp_enqueue_style( ... );
    wp_enqueue_script( ... );
  }
});

उस विधि का उपयोग करके हम ग्राहक पक्ष सत्यापन को संभालने के लिए कुछ js स्क्रिप्ट्स को संलग्न कर सकते हैं, जैसे यह एक । उस स्क्रिप्ट का काम करने के लिए आवश्यक मार्कअप को आसानी से Custom_Reg\BaseFieldकक्षा को संपादित करने के लिए नियंत्रित किया जा सकता है ।

यदि हम पंजीकरण ईमेल को अनुकूलित करना चाहते हैं, तो हम मानक विधि और मेटा पर सहेजे गए कस्टम डेटा का उपयोग कर सकते हैं, हम उनका उपयोग ईमेल में कर सकते हैं।

अंतिम कार्य जिसे हम संभवतः कार्यान्वित करना चाहते हैं, निवेदन को डिफ़ॉल्ट पंजीकरण फ़ॉर्म से रोकना है, जितना आसान:

add_action( 'login_form_register', function() { exit(); } );

सभी फाइलें यहां एक जिस्ट में मिल सकती हैं


1
वाह, यह पंजीकरण कार्यक्षमता का एक पूर्ण नया स्वरूप है! यदि आप बिल्ट-इन पंजीकरण प्रक्रिया को पूरी तरह से ओवरराइड करना चाहते हैं तो यह एक अच्छा उपाय है। मुझे लगता है कि बिल्ट-इन पंजीकरण फॉर्म का उपयोग नहीं करना एक अच्छा विचार नहीं है क्योंकि आप खोए हुए पासवर्ड फॉर्म जैसी अन्य मुख्य विशेषताओं को ढीला कर देंगे। और फिर, एक नए पंजीकृत उपयोगकर्ता को साइन-इन करने के लिए पारंपरिक बैक-एंड लॉगिन फ़ॉर्म प्रदर्शित करना होगा।
फाबिन क्वात्रावाक्स

1
@FabienQuatravaux पासवर्ड और लॉग इन फॉर्म को हमेशा की तरह इस्तेमाल किया जा सकता है (बैकएंड)। हाँ, कोड अधूरा क्योंकि खो पासवर्ड और प्रवेश फार्म से संभाला नहीं कर रहे हैं, लेकिन ओ पी सवाल केवल पंजीकरण फार्म के बारे में था और जवाब पहले से ही बहुत लंबा अन्य कार्यक्षमताओं जोड़ने के लिए गया था ...
gmazzap

13

TLDR; निम्नलिखित फॉर्म को अपनी थीम में रखें, nameऔर idविशेषताएँ महत्वपूर्ण हैं:

<form action="<?php echo site_url('wp-login.php?action=register', 'login_post') ?>" method="post">
    <input type="text" name="user_login" value="Username" id="user_login" class="input" />
    <input type="text" name="user_email" value="E-Mail" id="user_email" class="input"  />
    <?php do_action('register_form'); ?>
    <input type="submit" value="Register" id="register" />
</form>

मुझे स्क्रैच से एक फैंसी वर्डप्रेस रजिस्टर फॉर्म बनाने पर एक उत्कृष्ट टट्सप्लस लेख मिला । यह फॉर्म को स्टाइल करने में अपना काफी समय खर्च करता है, लेकिन आवश्यक वर्डप्रेस कोड पर निम्नलिखित काफी सरल अनुभाग है:

चरण 4. वर्डप्रेस

यहां कुछ भी फैंसी नहीं है; हमें केवल दो वर्डप्रेस स्निपेट की आवश्यकता है, जो wp-login.php फ़ाइल के भीतर छिपे हुए हैं।

पहला स्निपेट:

<?php echo site_url('wp-login.php?action=register', 'login_post') ?>  

तथा:

<?php do_action('register_form'); ?>

संपादित करें: मैंने लेख से अतिरिक्त अंतिम बिट को यह समझाने के लिए जोड़ा है कि उपरोक्त कोड स्निपेट कहां रखा जाए - इसका सिर्फ एक रूप है ताकि यह किसी भी पृष्ठ टेम्पलेट या साइडबार में जा सके या इसके बाहर एक शोर्ट बना सके। महत्वपूर्ण खंड वह है formजिसमें उपरोक्त स्निपेट्स और महत्वपूर्ण आवश्यक फ़ील्ड शामिल हैं।

अंतिम कोड ऐसा दिखना चाहिए:

<div style="display:none"> <!-- Registration -->
        <div id="register-form">
        <div class="title">
            <h1>Register your Account</h1>
            <span>Sign Up with us and Enjoy!</span>
        </div>
            <form action="<?php echo site_url('wp-login.php?action=register', 'login_post') ?>" method="post">
            <input type="text" name="user_login" value="Username" id="user_login" class="input" />
            <input type="text" name="user_email" value="E-Mail" id="user_email" class="input"  />
                <?php do_action('register_form'); ?>
                <input type="submit" value="Register" id="register" />
            <hr />
            <p class="statement">A password will be e-mailed to you.</p>


            </form>
        </div>
</div><!-- /Registration -->

कृपया ध्यान दें कि यह वास्तव में महत्वपूर्ण है , और आवश्यक है, user_loginnameऔर के रूप मेंid अपने पाठ इनपुट में विशेषता; ईमेल इनपुट के लिए भी यही सच है। अन्यथा, यह काम नहीं करेगा।

और इसके साथ, हम कर रहे हैं!


महान समाधान! सरल और कुशल। लेकिन आप उन स्निपेट्स को कहाँ रखते हैं? एक साइडबार में? यह टिप सीम केवल अजाक्स पंजीकरण फॉर्म के साथ काम करता है।
फाबिन क्वात्रावाक्स

1
धन्यवाद @FabienQuatravaux, मैंने लेख के अंतिम खंड को शामिल करने के लिए उत्तर अपडेट किया है। AJAX फॉर्म की कोई आवश्यकता नहीं होनी चाहिए - इसका सिर्फ एक POST फॉर्म जो wp-login.php?action=registerपेज को सबमिट करता है
icc97

6

यह लेख आपको अपने स्वयं के फ्रंटेंड रजिस्टर / लॉगिन / पासवर्ड फॉर्म को पुनर्स्थापित करने के तरीके के बारे में एक बढ़िया ट्यूटोरियल प्रदान करता है।

या यदि आप एक प्लगइन की तलाश कर रहे हैं तो मैंने पहले इनका उपयोग किया है और इन्हें फिर से जोड़ सकता है:


4

मैंने कुछ समय पहले एक वेबसाइट बनाई थी जो फ्रंट एंड साइड पर कस्टमाइज्ड रजिस्ट्रेशन फॉर्म प्रदर्शित कर रही थी। यह वेबसाइट अब लाइव नहीं है लेकिन यहां कुछ स्क्रीनशॉट हैं। लॉगइन फॉर्म पंजीकरण फॉर्म पासवर्ड फॉर्म खो दिया है

यहाँ मैं निम्नलिखित चरणों का पालन कर रहा हूँ:

1) सेटिंग्स> जनरल> सदस्यता विकल्प के माध्यम से सभी आगंतुकों के लिए एक नए खाते का अनुरोध करने की संभावना को सक्रिय करें। अब पंजीकरण पृष्ठ URL /wp-login.php?action=register पर दिखाई देता है

2) पंजीकरण फॉर्म को कस्टमाइज़ करें ताकि यह आपकी साइट के फ्रंट-एंड जैसा दिखे। यह अधिक मुश्किल है और आपके द्वारा उपयोग किए जा रहे विषय पर निर्भर करता है।

यहाँ एक उदाहरण के साथ बीसवीं है:

// include theme scripts and styles on the login/registration page
add_action('login_enqueue_scripts', 'twentythirteen_scripts_styles');

// remove admin style on the login/registration page
add_filter( 'style_loader_tag', 'user16975_remove_admin_css', 10, 2);
function user16975_remove_admin_css($tag, $handle){
    if ( did_action('login_init')
    && ($handle == 'wp-admin' || $handle == 'buttons' || $handle == 'colors-fresh'))
        return "";

    else return $tag;
}

// display front-end header and footer on the login/registration page
add_action('login_footer', 'user16975_integrate_login');
function user16975_integrate_login(){
    ?><div id="page" class="hfeed site">
        <header id="masthead" class="site-header" role="banner">
            <a class="home-link" href="<?php echo esc_url( home_url( '/' ) ); ?>" title="<?php echo esc_attr( get_bloginfo( 'name', 'display' ) ); ?>" rel="home">
                <h1 class="site-title"><?php bloginfo( 'name' ); ?></h1>
                <h2 class="site-description"><?php bloginfo( 'description' ); ?></h2>
            </a>

            <div id="navbar" class="navbar">
                <nav id="site-navigation" class="navigation main-navigation" role="navigation">
                    <h3 class="menu-toggle"><?php _e( 'Menu', 'twentythirteen' ); ?></h3>
                    <a class="screen-reader-text skip-link" href="#content" title="<?php esc_attr_e( 'Skip to content', 'twentythirteen' ); ?>"><?php _e( 'Skip to content', 'twentythirteen' ); ?></a>
                    <?php wp_nav_menu( array( 'theme_location' => 'primary', 'menu_class' => 'nav-menu' ) ); ?>
                    <?php get_search_form(); ?>
                </nav><!-- #site-navigation -->
            </div><!-- #navbar -->
        </header><!-- #masthead -->

        <div id="main" class="site-main">
    <?php get_footer(); ?>
    <script>
        // move the login form into the page main content area
        jQuery('#main').append(jQuery('#login'));
    </script>
    <?php
}

फिर फॉर्म को प्रकट करने के लिए थीम स्टाइलशीट को संशोधित करें जैसा आप चाहते हैं।

3) आप प्रदर्शित संदेशों को ट्विक करके फ़ॉर्म को संशोधित कर सकते हैं:

add_filter('login_message', 'user16975_login_message');
function user16975_login_message($message){
    if(strpos($message, 'register') !== false){
        $message = 'custom register message';
    } else {
        $message = 'custom login message';
    }
    return $message;
}

add_action('login_form', 'user16975_login_message2');
function user16975_login_message2(){
    echo 'another custom login message';
}

add_action('register_form', 'user16975_tweak_form');
function user16975_tweak_form(){
    echo 'another custom register message';
}

4) यदि आपको फ्रंट-एंड पंजीकरण फॉर्म की आवश्यकता है, तो आप शायद यह नहीं चाहेंगे कि पंजीकृत उपयोगकर्ता लॉग-इन करते समय बैकएंड को देखें।

add_filter('user_has_cap', 'user16975_refine_role', 10, 3);
function user16975_refine_role($allcaps, $cap, $args){
    global $pagenow;

    $user = wp_get_current_user();
    if($user->ID != 0 && $user->roles[0] == 'subscriber' && is_admin()){
        // deny access to WP backend
        $allcaps['read'] = false;
    }

    return $allcaps;
}

add_action('admin_page_access_denied', 'user16975_redirect_dashbord');
function user16975_redirect_dashbord(){
    wp_redirect(home_url());
    die();
}

बहुत सारे कदम हैं, लेकिन परिणाम यहाँ है!


0

आसान तरीका: वर्डप्रेस फ़ंक्शन wp_login_form()( कोडेक्स पेज यहां ) का उपयोग करें।

आप अपना खुद का प्लगइन बना सकते हैं ताकि आप अपने पृष्ठों पर एक शोर्ट का उपयोग कर सकें:

<?php
/*
Plugin Name: WP Login Form Shortcode
Description: Use <code>[wp_login_form]</code> to show WordPress' login form.
Version: 1.0
Author: WP-Buddy
Author URI: http://wp-buddy.com
License: GPLv2 or later
*/

add_action( 'init', 'wplfsc_add_shortcodes' );

function wplfsc_add_shortcodes() {
    add_shortcode( 'wp_login_form', 'wplfsc_shortcode' );
}

function wplfsc_shortcode( $atts, $content, $name ) {

$atts = shortcode_atts( array(
        'redirect'       => site_url( $_SERVER['REQUEST_URI'] ),
        'form_id'        => 'loginform',
        'label_username' => __( 'Username' ),
        'label_password' => __( 'Password' ),
        'label_remember' => __( 'Remember Me' ),
        'label_log_in'   => __( 'Log In' ),
        'id_username'    => 'user_login',
        'id_password'    => 'user_pass',
        'id_remember'    => 'rememberme',
        'id_submit'      => 'wp-submit',
        'remember'       => false,
        'value_username' => NULL,
        'value_remember' => false
), $atts, $name );

// echo is always false
$atts['echo'] = false;

// make real boolean values
$atts['remember']       = filter_var( $atts['remember'], FILTER_VALIDATE_BOOLEAN );
$atts['value_remember'] = filter_var( $atts['value_remember'], FILTER_VALIDATE_BOOLEAN );

return '<div class="cct-login-form">' . wp_login_form( $atts ) . '</div>';

}

आपको बस इतना करना है कि आप अपने फॉर्म को फ्रंटेंड पर स्टाइल करें।


-1

यदि आप प्लगइन्स के उपयोग के लिए खुले हैं, तो मैंने पहले ग्रेविटी फॉर्म के लिए उपयोगकर्ता पंजीकरण ऐड-ऑन का उपयोग किया है, यह बहुत अच्छी तरह से काम करता है:

http://www.gravityforms.com/add-ons/user-registration/

संपादित करें: मुझे पता है कि यह बहुत विस्तृत समाधान नहीं है, लेकिन यह ठीक वही है जो आपको चाहिए और एक अच्छा समाधान है।

संपादित करें: मेरे उत्तर पर और विस्तार करने के लिए, उपयोगकर्ता पंजीकरण एड-ऑन गुरुत्वाकर्षण रूपों के लिए आपको उपयोगकर्ता-विशिष्ट फ़ील्ड्स के लिए गुरुत्वाकर्षण प्रपत्र का उपयोग करके बनाए गए फॉर्म में किसी भी फ़ील्ड को मैप करने की अनुमति देता है। उदाहरण के लिए, आप पहले नाम, अंतिम नाम, ईमेल, वेबसाइट, पासवर्ड के साथ एक फॉर्म बना सकते हैं। प्रस्तुत करने पर, ऐड-ऑन उन इनपुट को संबंधित उपयोगकर्ता फ़ील्ड में मैप करेगा।

इसके बारे में एक और बढ़िया बात यह है कि क्या आप किसी पंजीकृत उपयोगकर्ता को अनुमोदन कतार में जोड़ सकते हैं। एक व्यवस्थापक द्वारा बैकएंड में अनुमोदित किए जाने के बाद ही उनके उपयोगकर्ता खाते बनाए जाएंगे।

यदि उपरोक्त लिंक टूट जाता है, तो बस Google "उपयोगकर्ता पंजीकरण ग्रेविटी फॉर्म के लिए जोड़ें"


2
क्या आपने नोट पढ़े हैं @kaiser ने सवाल (बोल्ड मेरा) में जोड़ा: "हम लंबे उत्तर की तलाश कर रहे हैं जो कुछ स्पष्टीकरण और संदर्भ प्रदान करते हैं । केवल एक-पंक्ति का उत्तर न दें; समझाएं कि आपका उत्तर सही क्यों है, आदर्श रूप से; । उद्धरणों का जवाब है कि स्पष्टीकरण शामिल नहीं हैं हटाया जा सकता है "
gmazzap

मेरे पास है, लेकिन मुझे लगा कि ऐड अभी भी ध्यान देने योग्य है, क्योंकि ओपी ने कस्टम कोड की आवश्यकता का उल्लेख नहीं किया है। यह टिप्पणी करने के लिए इसे स्थानांतरित करने के लिए खुश यदि आपको लगता है कि यह आवश्यक है
जेम्स केम्प

मैं एक मॉड नहीं हूँ, इसलिए मैं आपके उत्तर पर टिप्पणी करने के लिए नहीं जा सकता। मैं केवल वोट कर सकता हूं, लेकिन मैंने ऐसा नहीं किया है क्योंकि मुझे लगता है कि आपके लिंक में उपयोगी जानकारी है, हालांकि, लिंक-ओनली उत्तर उपयोगी नहीं है, यहां तक ​​कि क्योंकि लिंक आसानी से बदल सकता है और इसलिए आपका उत्तर 404 पर आता है। यहां प्रासंगिक कोड की रिपोर्ट करने और वाह कोड की व्याख्या करने की कोशिश करें, फिर आपका उत्तर ठीक है, मुझे लगता है।
गमजप

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

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